Circuito Lógico para Senha de Cofre

     Em pedido do leitor Carlos Guilherme Assunção, farei um post explicando um exercício específico. O exercício consiste em criar um sistema de senha de cofre utilizando Flip-Flops tipo D, onde haverá uma senha já armazenada e uma senha a ser colocada. Devido a simplicidade, eu optei por fazer a senha com 2 bits, o que consiste em 4 combinações de senhas possíveis, mas a estrutura que vou explicar pode ser expandida para quantos bits forem necessários.

     A primeira estrutura que imagino possui apenas 2 FF (Flip-Flops) tipo D, que serve para armazenar temporariamente a senha digitada. Eu usaria uma DIP-Switch para colocar a senha e uma tecla push-button que funcionaria como o enter da senha. A senha seria digitada em binário via DIP-Switch, pois fazer um teclado decimal necessitaria de decodificadores decimal-binário, e optei por usar DIP-Switch se não seria necessário criar uma retenção para as teclas.

     Vamos explicar essa estrutura. Cada um dos dois FF tipo D servem para armazenar a senha digitada. Cada bit da senha é escolhido através dos flags 'senha digitada', que ficam na entrada D de cada FF. O nível lógico desses flags podem ser implementados na prática por um circuito com DIP-Switch. Porém o clock dos FF está ligado no flag 'Enter', que deve ser implementado com uma chave sem retenção, ou seja, ele deve ser só um pulso positivo, pois o que nos interessa é a borda de subida do sinal.

     Quando o botão 'Enter' é pressionado, ocorre uma borda de subida do sinal do clock dos FF e, então, eles leem o nível de tensão da entrada D e a colocam na saída. Dessa forma cada bit de saída dos FF são comparados via porta XNOR com o respectivo bit da senha correta, previamente armazenada no sistema. A saída da porta XNOR só será um se as duas entradas possuírem mesmo valor lógico, ou seja, se o bit da senha digitado seja igual ao respectivo bit da senha armazenada. No fim o resultado de cada comparação é colocado na entrada de uma porta AND, cuja saída só será '1' se todas as entradas forem '1', ou seja, se todos os bits da senha digitada forem iguais aos bits da senha certa já armazenada.

     Neste caso, e somente neste caso, a saída será 1 e o cofre abrirá.

     Para aumentar a quantidade de bits dessa estrutura basta adicionar FF tipo D e portas XNOR na saída e, no fim, colocar todas as saídas das portas XNOR e uma porta AND com entradas suficientes. Essa é a estrutura básica que pode ser aprimorada para resolver alguns problemas práticos.

     Um dos problemas é que a saída fica em '1' após ser digitada a senha correta até que uma senha errada seja digitada. Isso pode ser corrigido com algum sistema de temporização que, após um tempo, acione o reset assíncrono dos FF.

     E, por enquanto era isso. Talvez se esse assunto necessitar de mais aprofundamento, farei outro post sobre isso. Espero que tenha sido útil. Abraço e até a próxima.

Flip-Flop D e Flip-Flop T (funcionamento)

     Olá! Vamos então aos poucos dando continuidade a série de posts sobre eletrônica digital, já que esse semestre serei monitor da disciplina de sistemas digitais na universidade na qual estudo. Hoje vou falar de um outro tipo de Flip-Flop, o Tipo D (Data). Esse post é um dos post que serão feitos a pedido do leitor Carlos Guilherme Matos Assunção.

Flip-Flop Tipo D

     O Flip-Flop Tipo D possui basicamente 2 entradas e 2 saídas. As duas entradas são a de Clock (Clk) e a entrada Data (D), onde o bit do dado é colocado. As duas saídas são as já conhecidas Q e Q' (Q e Q barrado). Para nossos exemplos vamos considerar que o flip-flop seja acionado pela borda de subida do clock e, por enquanto, vamos ignorar as entradas assíncronas Preset e Clear.

     Este flip-flop funciona da seguinte maneira: quando um pulso de clock chegar na entrada Clk, a borda positiva (de subida) desse pulso fará o flip-flop ler o valor lógico da entrada D e transferir o mesmo valor de D para a saída Q (obviamente, fazendo Q' (Q barrado) assumir o valor contrário de Q). Esse valor ficará na saída Q até que um próximo pulso de clock chegue na entrada Clk. Então sua borda de subida ocasionará uma nova leitura da entrada D e uma nova atualização das saída Q e Q'.

     Dessa forma o FF (Flip-Flop) tipo D é um flip-flop que armazena o bit que está em sua entrada de acordo com seus sinais de clock.

     Por exemplo, se quiséssemos construir um circuito que armazenasse 8 bits simultaneamente, poderíamos usar 8 FF tipo D em paralelo, cada um armazenando um dos oito bits.

     Vamos considerar as entradas assíncronas Preset e Clear. Elas são chamadas assíncronas pois não dependem do clock. Deixe-me explicar melhor.

     O valor na entrada D pode provocar uma alteração na saída, mas somente na presença da borda de subida do clock. Fora dessa situação (da presença da borda de subida) o valor da entrada D não altera a as saída Q e Q' do FF. Portanto a entrada tipo D é dita síncrona, pois respeita o clock.

     As entradas assíncronas são aquelas que não respeitam o clock, ou seja, a saída responde a essas entradas independentemente do estado do clock. As entradas Preset e Clear funcionam da seguinte forma:

     A entrada Preset é barrada, invertida, ou seja, é acionada com valor 0 e fica inerte com valor 1. Se colocamos o valor 0 no Preset o ativamos e a saída Q se torna 1 (consequentemente a saída Q' = 0) independente da situação do clock nesse instante. Com o Preset em 1 ele fica inativo e não altera o comportamento do FF.

     A entrada Clear, assim como o Preset, também é invertida, ou seja, também é acionada com o valor 0. Se a entrada Clear recebe valor 0, a saída Q se torna 0 (e, com isso, Q' = 1) independente do valor do clock nesse instante. Com o valor 1 na entrada Clear ela também fica inativa e não altera o funcionamento do FF.

     É importante lembrar que as duas entradas assíncronas não devem ficar ativas ao mesmo tempo, ou seja, Preset e Clear não devem receber valor 0 simultaneamente, pois isso faz as duas saídas (Q e Q') assumirem valor 1, o que pode corromper o funcionamento lógico do circuito digital onde esse FF tipo D está inserido.

Flip-Flop Tipo T

     O flip-flop tipo T, assim como o tipo D, também possui 2 entradas e 2 saídas. As saídas são nomeadas igualmente (Q e Q') e ele também possui uma entrada de clock, apenas trocando a entrada D (Data) por uma entrada tipo T (Toggle), que possui outra função. Novamente vamos considerar que o flip-flop seja acionado pela borda de subida do clock e vamos desconsiderar as entradas assíncronas Preset e Clear, que funcionam exatamente igual às entradas assíncronas do FF tipo D.

     Quando houver uma borda de subida, o FF tipo T irá ler o valor em sua entrada T. Caso o valor lido seja 0, a saída do flip-flop não irá se alterar. Caso a entrada T seja 1, o FF irá inverter suas saídas, ou seja, se Q era 1 irá passar para 0, e se Q era 0, irá passar para 1. Esse é o significado do nome desse flip-flop, pois toggle significa alternar, ou seja, ao ler o valor 1 em sua entrada durante a borda de subida do clock, o FF altera seus valores de saída. Sempre lembrando que a saída Q' (Q barrado) sempre terá o valor contrário da saída Q.

     E por hoje era isso. Espero que tenham gostado do post e entendido seu conteúdo. Abraço, até a próxima e continuem estudando.

Algoritmo e Programação - Algoritmos Condicionais

Olá a todos. Hoje vamos falar um pouco sobre algoritmos condicionais em C.

     Um algoritmo condicional representam uma tomada de decisão a partir de uma condição, que pode ser verdadeira ou falsa. Um programa pode por exemplo decidir se um aluno está aprovado ou não a partir de suas notas. Se a média do aluno for maior que 6, por exemplo, o programa pode apresentar a mensagem 'aprovado' e, caso contrário, apresentar a mensagem 'reprovado'. Vamos escrever esse programa, utilizando os conhecimentos de funções apresentados no último post sobre algoritmo e programação.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include >stdio.h<
#include >stdlib.h< //desinverter os símbolos de maior e menor, pois se eu escrever da maneira certa,
//o blogger entende como código HTML e "come" a expressão

float nota_1 = 0, nota_2 = 0, nota_3 = 0, media = 0;

float calculo_media (float n1, float n2, float n3)

{

    float media_aritmetica;

    media_aritmetica = (n1+n2+n3)/3;

    return media_aritmetica;

}

main()

{

    printf("Digite nota 1: ");

    scanf("%f",&nota_1);

    printf("Digite nota 2: ");

    scanf("%f",&nota_2);

    printf("Digite nota 3: ");

    scanf("%f",&nota_3);

    media = calculo_media(nota_1, nota_2, nota_3);

    printf("A media calculada foi de: %f.\n",media);

    if(media >= 6)

        printf("Aluno aprovado!");

    else

        printf("Aluno reprovado!");

    system("pause");

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

     Este programa é similar ao do último post sobre programação, com a adição da parte condicional, que são as linhas entre o if(media >= 6), e a linha printf("Aluno reprovado!"). Todas as outras linhas estão explicadas no último post, e as quatro linhas que eu fiz referência colocando em negrito, eu vou explicar agora.

if(media > 6)

     Esta linha executa um teste lógico 'o valor da variável media é maior ou igual a 6?'. Se a resposta for sim, o programa executa a linha abaixo do comando 'if', que é o comando printf("Aluno aprovado!"). Depois disso, o programa continua na linha system("pause").

else

     Esta linha funciona da seguinte forma: se o teste do if(media >= 6) for falso, ou seja, o valor da variável media não for maior nem igual a 6 (menor que 6), o programa vai executar somente a linha imediatamente após o else, ou seja, o comando printf("Aluno reprovado!"). Após isso o programa continua no comando system("pause").

     Porém este caso só pode ser usado se existir apenas um comando (uma linha) após o if e após o else. Porém muitas vezes necessitamos utilizar mais de um comando caso uma condição seja verdadeira ou falsa.
Então vamos escrever o mesmo código acrescentando mais comandos após o if e o else.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include >stdio.h< //desinverter os símbolos de maior e menor, pois se eu escrever da maneira certa,
//o blogger entende como código HTML e "come" a expressão

float nota_1 = 0, nota_2 = 0, nota_3 = 0, media = 0;

float calculo_media (float n1, float n2, float n3)

{

    float media_aritmetica;

    media_aritmetica = (n1+n2+n3)/3;

    return media_aritmetica;

}

main()

{

    printf("Digite nota 1: ");

    scanf("%f",&nota_1);

    printf("Digite nota 2: ");

    scanf("%f",&nota_2);

    printf("Digite nota 3: ");

    scanf("%f",&nota_3);

    media = calculo_media(nota_1, nota_2, nota_3);

    printf("A media calculada foi de: %f.\n",media);

    if(media >= 6)
    {

        printf("Aluno aprovado!\n");
        printf("Continue com seu bom desempenho!");
    }

    else
    {

        printf("Aluno reprovado!\n");
        printf("Boa sorte semestre que vem!");
    }

    system("pause");

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

     Aqui vou introduzir o conceito de bloco de código. Perceba que após o comando if agora existem um trecho de código (dois printf's) que estão entre chaves. As chaves delimitam este bloco de código, que para o programa é como se fosse um comando só. Isso permite que coloquemos mais comandos no comando if...else. E poderiam haver mais comandos dentro das chaves, não apenas os dois usados neste exemplo.

     MAIS SOBRE O PRINTF()

     Outra novidade está dentro do printf. Perceba que existe um \n dentro do primeiro printf após o if e após o else. Este /n é um comando utilizado dentro do printf que indica que deve-se pular a linha. Desta forma o programa entende que se deve pular uma linha ao chegar naquele 'caractere especial'.

      Outros caracteres especiais são o \t, que acrescente uma tabulação (um TAB) no texto e o \\, que indica que deve ser impresso o caractere \ (barra), o \" que imprime na tela o caractere " (aspas duplas), o \r que faz o cursor retornar para o início da linha, o \a que emite um sinal sonoro

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

      No próximo post mostrarei como fazer if...else aninhados, ou seja, if...else dentro de if...else. Dessa forma podemos fazer desvios considerando mais que duas condições. Com esta ferramenta, poderíamos fazer um programa que calcula a média e se fosse maior que 8 escrever parabéns, entre 6 e 8, escrever aprovado e menor que 6, escrever reprovado, por exemplo. Mas isto para o próximo post. Até lá, tente fazer a seguintes atividade.

1) Faça um programa que leia dois valores inteiros e, utilizando if e else, os escreva em ordem crescente no console (tela).
   
     Por hoje ficamos por aqui. Até a próxima e continuem estudando bastante. Qualquer dúvida, sugestão, comentário ou crítica deixe um comentário que respondo dentro de um dia. Abraço e até mais!