Algoritmo e Programação - If-Else Aninhados

     Olá a todos. Hoje vamos retomar a série de Algoritmo e Programação falando sobre if...else aninhados.

     Primeiro, o que são if...else aninhados? São if...elses dentro de outros if...elses e que servem para testar não somente duas condições, mas quantas condições quisermos. Vamos ver um exemplo que parte do algoritmo do último post, que pode ser visualizado clicando aqui. Este algoritmo calculava a média aritmética de três notas e exibia uma mensagem de aprovação, caso a média tivesse sido maior que 6, e de reprovação, caso a média tivesse sido menor que 6.

     Mas agora queremos fazer um upgrade neste algoritmo que, ao invés de mostrar somente mensagem de aprovação e reprovação, mostre outras mensagens, como por exemplo:

•      "Aprovado com louvor!" - Para uma média maior ou igual a 9;
•      "Aprovado! Parabéns!" - Para uma média maior ou igual a 8 e menor que 9;
•      "Aprovado!" - Para uma média maior ou igual a 7, mas menor que 8;
•      "Aprovado por pouco!" - Para uma média maior ou igual a 6, mas menor que 7;
•      "Reprovado!" - Para uma média menor que 6;

     Então perceba que após obtermos o cálculo da média não basta fazer uma comparação, pois isto nos daria somente se a média é maior ou menor a um único valor. Temos que ser capazes de comparar com vários valores (neste caso, com 9, 8, 7 e 6) para determinarmos em qual faixa o valor da média se encontra. Como fazemos isso? Utilizamos os if...else aninhados.

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

#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

#include >stdlib.h<

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 reprovado!\n\n");

    else

    {

        if( media < 7 )

            printf("Aluno aprovado por pouco!\n\n");

        else

        {

            if( media < 8 )

                printf("Aprovado!\n\n");

            else

            {

                if( media < 9 )

                    printf("Aprovado! Parabens!\n\n");

                else

                {

                    if (media ==10 )

                        printf("Aprovado com louvor!\n\n");

                }

            }

        }

    }

    system("pause");

}

     Compile este código no seu compilador e se convença do seu funcionamento. Após isto vamos discorrer um pouco sobre ele.

     Este código funciona, ele faz o que se propõe a fazer, mas ocupa muitas linhas. Utilizando de algumas propriedades da linguagem C, podemos reduzir drasticamente o numero de linhas do programa. Para testar, troque toda a função main do código anterior pela função main a seguir:

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 reprovado!\n\n");

    else

        if( media < 7 )

            printf("Aluno aprovado por pouco!\n\n");

        else  

            if( media < 8 )

                printf("Aprovado!\n\n");

            else     

                if( media < 9)

                    printf("Aprovado! Parabens!\n\n");

                else      

                    if( media == 10)

                        printf("Aprovado com louvor!\n\n");

    system("pause");

}

     Perceba que algumas linhas foram economizadas. Isso foi possível graças ao fato de que o comando if dentro do else é apenas um comando, independente do que existe dentro do if. E sendo um comando, não precisamos utilizar as chaves, que são necessárias apenas para blocos de comandos.

     Os comando if-else aninhados permitem fazer sequências de comparações utilizando um valor, um intervalo de valor, operações lógicas, enfim, tudo que o comando if em si aceita. 

     E por hoje era isso. Agora sabemos utilizar if-else aninhados para testar quantas condições quisermos! Então continuem estudando e até a próxima na série de programação. Abraço!

Registradores Paralelo, Série, Paralelo-Série e Série-Paralelo

     Olá a todos. Continuando a série sobre eletrônica digital, hoje vou falar sobre o que são registradores, sobre a sua implementação com Flip-Flops e sobre para que eles são usados em circuitos eletrônicos.

    O que são registradores? Bom, um flip-flop isolado é um dispositivo com capacidade de armazenamento de 1 bit. Os sistemas digitais geralmente utilizam barramentos de dados com largura maior que 1 bit, como, por exemplo. 8 bits, ou 16 bits. Para armazenar as informações que circulam por este barramento um flip-flop sozinho não dá conta. Por isso se utiliza um conjunto de flip-flops em uma associação conhecida como registrador. Um registrador de 8 bits, por exemplo, é uma associação de, no mínimo, 8 flip-flops. Esta associação é capaz de armazenar 8 bits.

     Os microcontroladores Microchip PIC contém registradores de 8 bits. Como no exemplo dos PICs , registradores são ocorrências muito comuns em sistemas digitais. Mas como é possível implementar um registrador com o que a gente já conhece?

     Bom, abaixo está o esquema de um registrador paralelo de 4 bits, implementado utilizando-se FF (Flip-Flops) tipo D. Este registrador recebe uma informação de 4 bits de forma paralela, e permite o acesso dessa informação de forma paralela também.

     Nesta imagem temos 4 FF tipo D. Cada entrada D do FF tipo D está conectada a uma via do barramento de entrada. Cada saída Q dos flip-flops tipo D está ligada a uma via do barramento de saída. Todos os clocks dos FF tipo D estão conectados entre si, assim como suas entradas assíncronas de preset e clear

     Assim conseguimos armazenar uma informação de 4 bits da seguinte forma. Seguramos as entradas assíncronas em 1, para o FF funcionar de forma síncrona. Colocamos a informação que queremos no barramento de dados, de 4 bits, e damos um pulso positivo na entrada de clocks desses FF. Dessa forma os dados do barramento de dados são transferidos para o barramento de saída, e ficará armazenada nesse barramento até um acionamento das entradas assíncronas, ou até um próximo pulso de clock, que fará um novo carregamento dos FF.

     Abaixo está a imagem de um registrador série de 4 bits, implementado utilizando-se também FF tipo D. Este registrador recebe a informação de forma série e transmite a informação de forma série. Esse registrador também é conhecido como registrador de deslocamento.

     Para entrar com informação nesse FF procedemos da seguinte forma. Mantemos as entradas assíncronas em 1, para os FF funcionarem no modo síncrono. Então colocamos um bit na entrada serial e, ao dar um pulso positivo de clock, essa informação passa para a saída do primeiro FF. Colocamos outra informação na entrada serial e damos outro pulso positivo de clock. Assim o que está na saída do 1° FF (e, portanto, está na entrada do 2°FF) passa para a saída do 2° FF, e o que está na entrada serial passa para a saída do 1° FF. Após 4 pulsos de clock, o que foi colocado na entrada serial por primeiro irá sair na saída serial, e todos os dados subsequentes estarão dentro desse registrador. Ao dar mais pulsos de clock conseguimos recuperar as informações no "meio" dele.

     Esses registradores entram e saem com a informação da mesma forma. Mas é possível criar registradores com entrada em série e saída paralela, ou o contrário, um registrador com entrada paralela e saída série. E vamos ver agora como fazer isso.

     Na imagem abaixo está a imagem de um registrador série-paralelo. Perceba que essa configuração é muito próxima da configuração do registrador série. A diferença é que ao invés de remover a informação de forma serial, na saída do último FF, tiramos a saída de forma paralela, ou seja, da saída de cada FF independente, e depois podemos dar um pulso no Clear (Reset) para zerar todos os FF do registrador. Podemos também somente empurrar uma nova informação sem zerar todos os FF. Após "empurrar" 4 novos bits para dentro do registrador, teremos somente a nova informação.

     Cada um dos flags com ponto de interrogação nas saídas dos FF é uma das saídas do registrador.

     Por fim temos um registrador paralelo-série, um registrador onde a informação é carregada para dentro do registrador de forma paralela e então deslocada para fora de forma série. A configuração deste registrador está mostrada abaixo:

     Neste registrador existe uma entrada de clock, de dados seriais, as entradas paralelas, um enable das entradas paralelas, uma entrada clear e a saída serial. Primeiro zeramos todo o registrador aplicando nível 0 na entrada assíncrona de Clear. Então voltamos a aplicar nível 1 na entrada Clear e aplicamos nível 1 na entrada Enable. Dessa forma o dado que estiver nas entradas paralelas irão aparecer na saída dos FF via entrada assíncrona Preset. Após isso colocamos nível 0 no Enable para fazer os FF operarem no modo síncrono novamente.

     Após isso cada pulso de clock desloca o conteúdo dos FF no sentido da saída serial. Os espaços que vão sendo desocupados (começando pelo 1° FF) vão sendo preenchidos pelo valor que está na entrada serial (que, neste caso, é 0). Após deslocarmos 4 vezes a saída, teremos todo o registrador preenchido pelo valor da entrada serial (neste caso, todo o registrador preenchido por 0's). Depois disso o FF está pronto para receber um novo conteúdo das entradas paralelas via habilitação da entrada Enable.

     Pode-se ver as estruturas detalhadas neste post, de forma um pouco mais elaborada, em dois CIs, que são o 74HC595 e o 74HC165. O primeiro é um registrador de 8 bits com entrada serial e saída paralela de 8 bits. No datasheet ele mostra a implementação de registradores tipo D utilizando FF SR. Ele possui um arranjo de FF na saída, que é outro registrador de entrada paralela com saída paralela. Tudo isto pode ser visto na página 5 do datasheet da Texas Instruments.

     O segundo, 74HC165, é um registrador de 8 bits de entrada paralela e saída serial. Percebe-se a mesma estrutura do registrador paralelo-série que expliquei aqui, de forma não muito mais elaborada. O circuito lógico pode ser encontrado na página 2 do datasheet da Texas Instruments.

     Para que serve estes registradores? Bom, imagine que você queira ler 8 entradas usando um microcontrolador. Se você fizer da maneira padrão, cada entrada em um pino do microcontrolador, você acabará utilizando 8 pinos do mesmo. Mas você pode usar um registrador paralelo-série! Dessa forma, as 8 entradas vão para o registrador. O microcontrolador controla o clock de deslocamento e o controle de carregamento dos bits. Enfim, com esta configuração pode-se ler 8 bits utilizando-se apenas 3 pinos do microcontrolador. O custo disso é a velocidade, pois como leremos as entradas em série, teremos uma diminuição de velocidade.

     O registrador série-paralelo funciona para a situação inversa, ou seja, quando queremos escrever em 8 saídas, mas não queremos disponibilizar 8 pinos do microcontrolador para isso. Assim utilizamos 1 pino para a saída da informação em série, 1 pino para o clock do deslocamento, 1 pino de reset assíncrono do registrador, 1 pino de clock para mandar a informação do registrador de entrada para o de saída (lembrando que este CI possui dois registradores internos, conforme datasheet) e um pino que coloca a saída em estado de alta impedância (tri-state). Dessa forma utilizando 5 pinos conseguimos escrever em 8 saídas.

     O interessante é que para escrever em 16 saídas não precisamos utilizar 10 pinos, pois é possível associar estes CIs de forma que eles se comportem como um só, ou seja, utilizando os mesmos 5 pinos conseguimos escrever em 16 saídas. O custo disso, novamente, é a perda de velocidade quando comparado com escrever nas saídas de forma paralela direta.

     E por hoje era isso. Acredito que tenha sido um post completo e esclarecedor, mas a opinião que realmente importa é a opinião do leitor. Então espero que tenham gostado. Um grande abraço e continuem estudando. Como sempre, qualquer dúvida, sugestão ou correção, deixe um comentário. Abraço e até a próxima!

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!

Problemas em Placas Devido ao Excesso de Fluxo de Solda

Olá a todos. Bem, como todos sabem, sou técnico em eletrônica industrial formado pelo SENAI Nilo Peçanha em Caxias do Sul (RS). Trabalho a pouco mais de um ano em uma empresa da cidade com eletrônica. Eu me considero um técnico geral dentro desta empresa, pois faço de tudo, desde funções "não técnicas", como fazer a furação das caixas dos produtos e embalá-los para enviar aos clientes, como funções "mais técnicas", como montagem SMD (manual e com Pick&Place), teste de produtos e pequenos projetos internos de propósito geral. Mas dentro das minhas funções há duas que eu exerço com mais apreço, que são elaboração de laudos técnicos e consertos internos.

Deixe-me detalhar melhor. Os consertos internos são produtos que deram defeitos durante os testes. Os técnicos que fazem os testes na produção marcam as peças e eu os auxilio nos consertos, já que muitas vezes eles não tem tempo para interromper o fluxo produtivo para consertar uma peça.

Os laudos técnicos são análises de produtos que deram defeitos em campo. Estas análises têm por objetivo, além de determinar se a garantia do produto será aprovada ou não, reconhecer falhas de projeto ou no processo de produção dos produtos. Estas informações são valiosas para aprimorar de forma contínua o nosso produto.

Hoje quero alertar os que trabalham com eletrônica sobre o resultado de um dos laudos que eu elaborei, onde foi percebido que o fluxo de solda pode, com o tempo, começar a conduzir corrente elétrica, podendo fazer com que circuitos sensíveis parem de funcionar.

Era um circuito de rádio frequência em que um dos componentes tem encapsulamento QFN, como o mostrado na figura abaixo.

O problema é que nem sempre esse componente saia do forno de refusão soldado corretamente, e correções a mão muitas vezes tinham de ser feitas. Mas para consertar as soldas neste componente é usado um fluxo pastoso RMA (acredito que seja um tipo comum de fluxo) que possui coloração amarela.

O fluxo é adicionado no local da soldagem para limpar impurezas do local, como oxidações, que impedem que se forme a junção entre as ligas metálicas. A adição de fluxo facilita muito a soldagem. Tanto que o próprio estanho em rolo possui, dentro dele, uma quantidade de fluxo pastoso. Algumas coisas que você deve saber:

* A temperatura para fundir a liga eutética estanho-chumbo (proporção 63% Sn e 37% Pb) é de 183°C. A temperatura recomendada na ponta do ferro de solda para soldar componentes SMD é de cerca de 220°C;

*A fumaça que sai da ponta do ferro de solda, ao ser adicionado estanho nele, é na verdade do fluxo de solda contido dentro do estanho. Tanto é verdade que depois de um tempo todo o fluxo evapora e nota-se que para de sair aquela fumaça;

*Ao estanhar você já se queimou com aqueles "respingos" que saem da área soldada? Pois bem, aquilo não é estanho. O que ocorre é que se você aquecer muito rapidamente o estanho, parte do fluxo dentro dele evapora (já que precisa de uma temperatura menor para evaporar do que o estanho precisa para fundir). Com isso, o fluxo evapora e expande dentro de uma barreira sólida de estanho. Basta a liga de estanho fundir para "explodir", liberando pequenas gotas de fluxo quente, mas que não conseguiu evaporar.

Este fluxo não apresentava nenhum problema no produto durante nossos testes, de forma que algumas vezes os circuitos saiam com excesso de fluxo circundando os componentes. Mas depois de um tempo alguns produtos começaram a retornar com problemas misteriosos. O circuito de rádio frequência parava de se comunicar com o microcontrolador (comunicação através de uma trilha, e  não através do meio). Sempre que ressoldávamos os componentes do circuito de rádio frequência, o equipamento voltava a funcionar corretamente. Dessa forma concluímos que o problema era alguma solda fria, que causava mal contato em algum dos pads de comunicação entre o circuito de RF e o microcontrolador.

Durante um treinamento realizado na empresa sobre técnicas de montagem SMD, o instrutor do treinamento, ao ser questionado, respondeu que o fluxo não conduz quando "novo", mas após um tempo em campo ele poderia absorver umidade e partículas de impureza e passar a conduzir devido a esta absorção.

Desconfiando que pudesse ser este o problema por nós enfrentado, decidimos fazer alguns testes no próximo produto que viesse apresentando os sintomas já bem conhecidos por nós.

Ao aparecer produtos com as características descritas, resolvemos, ao invés de soldar, apenas fazer uma limpeza do circuito de RF utilizando uma escova e álcool isopropílico. Após uma limpeza de leve, o produto voltou a funcionar corretamente, mesmo sem nenhuma solda ter sido refeita.

Ainda sobrava uma desconfiança. Achávamos que poderia ser realmente uma solda fria que, ao ser passada a escova, a pressão fez ela voltar a dar contato. Resolvemos então escovar novamente o circuito, desta vez utilizando muita força. Pensávamos que se fosse solda fria, ou alguma trilha solta, a força da escovação iria causar o mal contato da região defeituosa. Porém constatamos que mesmo após a escovação, o produto continuava funcionando de forma correta.

A partir desses dados, e de outros produtos com os mesmos problemas e tratados com a mesma abordagem, trabalhamos hoje com a ideia de que o excesso de fluxo pode realmente causar problemas em circuitos sensíveis, como de RF.

Disso tudo tiro algumas conclusões, que podem estar certas, ou não:

1) O fluxo resinoso RMA precisa ser limpado da placa. Na hora da soldagem ele parece incolor, mas depois de um tempo ele adquire o especto amarelado. Talvez o excesso seja resultado de uma soldagem incorreta (pouca temperatura ou tempo de exposição para ativação completa do fluxo), mas de qualquer forma, a história de que para o fluxo RMA não é necessária a remoção dos resíduos é errada.

2) Álcool isopropílico não remove o fluxo. Na verdade, remove de um lugar passando a sujeira para outro. Vale a pena investir em um solvente de fluxo. Atualmente estamos utilizando um limpador de fluxo baseado em ciclohexano e outros solventes. Ainda está em fase de observação para ver se não irá agredir as trilhas, as ilhas ou o verniz da placa.

3) Talvez seja uma boa ideia utilizar estanho com fluxo NoClean. O fluxo NoClean é um fluxo que, em princípio, não precisa de limpeza pelo fato de não deixar resíduos na placa. Adquirimos uma amostra grátis de estanho com esse fluxo e ele também está ainda na fase de testes, apresentando por enquanto resultados satisfatórios.

Estas são minhas conclusões e sugestões, baseadas na observação empírica e interpretadas segundo as teorias que eu conheço. Elas claro estão limitadas ao meu conhecimento e como não me declaro dono da verdade, posso estar errado. Mas se tivesse que aconselhar alguém hoje, eu diria: limpe o fluxo do seu circuito da melhor forma possível, principalmente se o circuito for sensível.

E por hoje era isto, Espero ter dado uma dica útil, já que esta assunto não é muito abordado na internet ( não achei nada sobre isso com facilidade). Enfim, qualquer comentário, sugestão ou vontade de compartilhar uma experiência parecida, fiquem a vontade para usar os comentário. Serão respondidos o mais breve possível. Continuem estudando e até a próxima.

Circuito Dimmer

Olá. Hoje vamos abordar um circuito clássico, a pedido de um leitor do blog. Hoje vamos falar do dimmer, que é um circuito que controla a tensão RMS aplicada a uma carga através de cortes na senóide da rede. Vamos entender mais sobre isso neste post. Antes vamos estudar a matemática sobre o dimmer. Mas primeiro recomendo você ler os posts Circuitos Retificadores: Visão Geral e Tensão Alternada (AC).

Vamos analisar a figura abaixo:

Nesta figura, percebemos que a senóide não começa em 0 radianos como deveria, mas começa o semiciclo positivo com radianos de atraso. Já no semicilo negativo, acontece algo semelhante. Ao invés de a tensão começar a ficar negativa no ângulo de radianos, a tensão começa a ficar negativa com o mesmo atraso de , ou seja, começa a ficar negativa no ângulo de radianos.

Podemos imaginar que a tensão RMS, ou seja, a tensão eficaz que esta onda apresenta é menor que a tensão RMS que a onda completa (sem esses cortes) apresentaria. Mas como calcular a tensão RMS exata desta onda?

Aproveitando a simetra entre os semicilos podemos calcular a tensão RMS considerando somente um semiciclo. Vamos fazer o cálculo RMS entre os ângulos 0 e , percebendo que a onda apresenta tensão somente entre e , vamos integrar a função senoide entre os limites e . Sendo Vp a tensão de pico da onda , ou seja,





Onde:

 

Caso você não entenda integração, não se preocupe, pode ficar com a segunda expressão que é, de fato, a resolução da integral acima.

A corrente RMS pode ser expressa simplesmente utilizando a Lei de Ohm:



Então vimos que se conseguirmos aplicar um atraso na senóide da rede, conseguiríamos controlar a tensão e corrente RMS aplicada em uma carga resistiva. O circuito que controla esse atraso é o circuito dimmer, cujo esquemático está ilustrado abaixo:

No circuito, ao alterar-se a resistência do potenciômetro P1, mudamos a constante de tempo da primeira malha RC, mudamos constante de tempo que ao passar pela segunda malha RC e chegar a tensão de disparo do DIAC, aciona o TRIAC e permite que a tensão da rede seja aplicada na carga.

Mas o esquema elétrico apresentado é para um Dimmer de 110V. Vamos agora olhar o adaptar o esquemático para um Dimmer de 220V.

Os capacitores devem aguentar uma tensão de, pelo menos, 400V de pico e 300V constante.

No esquema que montei existe um resistor em série com o pontenciômetro, de 5K6. O resistor de 300 Ohms foi substituído por um de 5K6 também e os capacitores usados foram de 47nF. O DIAC utilizado foi o DB3 e o TRIAC utilizado o BT138.

Este esquema funciona para a rede de 220V, pelo que me lembro, e consegue controlar bem a potência de uma lâmpada de 100W tranquilamente. Ao fazer a montagem, tome cuidado devido ao risco de choque elétrico e confira o datasheet dos componentes utilizados para verificar se eles atendem as exigências.

Por hoje era isso, abraço e até a próxima. Fui...