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...

Algoritmo e Programação - Calculando uma Média com Funções

Olá, quanto tempo! Pois é, época de provas na universidade, tive que estudar bastante, mas não esqueci do blog em momento algum, fiquem tranquilos, se é que alguém ainda lê isso. ;)

Vamos fazer um algoritmo sequencial que calcula uma média aritmética comum, e faremos isso de duas formas. Na primeira vamos fazer isso tudo em uma função principal, e na outra faremos uso de uma função destinada exclusivamente a fazer o cálculo da média aritmética.

#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, nota_2, nota_3, media;

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 = (nota_1+nota_2+nota_3)/3;

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

    system("pause");

}

Caso tenha dificuldade em entender os elementos do código, sugiro ler o post anterior, onde explico cada elemento usado nesse programa.

Nesse programa queremos calcular uma média aritmética entre três notas, ou seja, somaremos as três e dividiremos o resultado por três, e é exatamente isso que este código faz.

Porém conforme nosso código cresce em tamanho e complexidade, se torna útil dividi-lo em funções. As funções são trechos de código escritos fora do programa principal (main) e que, quando são necessário, podem ser chamados de dentro do trecho de código onde estamos. Vamos reescrever esse programa para que o cálculo da média seja feita dentro de uma função, mediante a passagem das notas para a função.

A função que calcula a média aritmética terá a seguinte cara:

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

{

    float media_aritmetica;

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

    return media_aritmetica;

}

Vamos analisar os elementos da função. Ela tem um nome. Essa função se chama calculo_media, pois é isso que ela faz, calcula a média. Não preciso dizer que é interessante nomear a função de forma que saibamos, por alto, o que ela faz.

Após o nome da função, entre parênteses, existe a lista de argumentos que a função recebe. Os argumentos são os dados que a função precisa saber para calcular funcionar corretamente. Nesse caso vamos calcular uma média. Para isso precisamos saber os valores das três notas, que nomeamos como n1, n2 e n3. Antes do nome das notas temos a palavra float, que indica que as variáveis são do tipo ponto flutuante, ou seja, podem conter números com vírgula, e não somente números inteiros. Pois todos sabem que a nota pode ser um número com vírgula, como 8,2 ou 9,5 (infelizmente as vezes as notas são mais baixas).

Antes do nome da função também temos a palavra float. Neste caso definimos o tipo de valor que a função retorna. Neste exemplo a função calcula a média e retorna para o código original o valor calculado para a média. Mais adiante, quando eu mostrar o exemplo completo, voltarei a falar sobre isso.

No restante do código da função, simplesmente criamos uma variável chamada media_aritmetica, que declaramos como sendo float, pois vai receber o valor da média que também poderá ser um número com vírgula. A segunda linha da função calcula a média através da soma e divisão e, por fim, existe o comando return que devolve o valor calculado pela função para o código original. Vamos agora ver o exemplo do código inteiro:

#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);

    system("pause");

}

Perceba que existe uma linha que diz que a média é igual a calculo_media(nota_1, nota_2, nota_3). Esta linha chama a função que calcula a média passando os valores da nota_1, nota_2 e nota_3 para as variáveis da função chamadas de n1, n2 e n3, respectivamente. Depois a função irá retornar a variável media_aritmetica, que será a média calculada, e esse valor será armazenado na variável media.

Espero que tenham entendido o básico de funções em C. Espero também que possam sozinhos aprofundar um pouco mais esses conhecimentos adquiridos com as práticas propostas abaixo. Qualquer dúvida não hesitem em comentar neste post.

Então teremos práticas, para aprofundarmos o nosso conhecimento sobre funções.

1) Teste esse código e procure entender seu funcionamento:

#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);

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

    system("pause");

}

2) Crie duas funções, uma para calcular a média entre duas notas e outra para calcular a média de três notas, e implemente um programa com essas funções.

Por fim, qualquer dúvida, sugestão (principalmente sugestões) ou comentário, deixe um comentário que responderei dentro de 1 dia útil. Abraço e bons estudos de programação.

Dicas para Cuidar da Estação de Solda

Olá a todos. Quanto tempo né? É que ultimamente estive muito ocupado com afazeres da universidade e do trabalho. Enfim, hoje vou dar algumas dicas sobre como cuidar da sua estação de solda. Essas informações foram passadas a mim na empresa em um treinamento que está sendo realizado na parte de solda de componentes SMD, que inclui solda por forno de refusão, solda onda e solda a mão, com fins de retrabalho.

Para começar, vamos diferenciar o estanhador comum e a estação de solda.

O estanhador basicamente consiste de um elemento resistivo que, ao ser ligado na rede elétrica, dissipa uma potência determinada, sendo os valores comuns 30W, 40W, 60W, 80W e 100W. O estanhador pode não ter a ponteira aterrada, ou seja, pode não estar protegida contra descargas eletrostáticas.

Já a estação de solda conta com uma ponta aterrada, protegendo componentes sensíveis de descargas eletrostáticas, além de um sensor de temperatura e um potenciômetro para ajuste da mesma, permitindo escolher a temperatura de solda entre valores de 150°C até 450°C (pelo menos nos modelos em que estou acostumado). A grande desvantagem da estação de solda é seu preço, muito superior ao do estanhador. Fazendo uma pesquisa rápida no mercado livre, encontrei ferros de solda (estanhador) de 60W por aproximadamente R$30,00, enquanto uma estação de solda, da mesma marca e de mesma potência, por R$140,00, ou seja, mais de 4 vezes o preço do estanhador.

Então o hobbista que investiu em uma estação de solda quer qualidade no seu trabalho e uma longa duração da sua ferramenta, devido ao alto custo. O funcionário de uma empresa, de mesma forma, que conservar sua ferramenta de trabalho, para obter maior qualidade nas suas soldas por mais tempo. Então aqui estão algumas coisas que você deve saber para aproveitar ao máximo sua estação de solda.

A maioria dos estanhos utilizados na indústria eletrônica para soldagem a mão são uma liga de estanho e chumbo. Ligas como Sn60Pb40, Sn63Pb37 e Sn62Pb36Ag2 possuem fusão completa, respectivamente, em temperaturas de 190°C, 183°C e 179°C. É aconselhado, para solda de componentes pequenos (SMD) usar uma temperatura de 220°C. Essa temperatura é suficiente para fundir a solda e insuficiente para danificar os componentes, desde que a fonte de calor (a ponta do ferro de solda) não seja deixada muito tempo no terminal. Utilizar temperaturas muito altas, como 350°C e 400°C permite uma solda muito mais rápida, mas devem ser usadas com cuidado, pois deixar o ferro da estação em repouso nessa temperatura danifica os elementos internos do ferro de solda, além dessa temperatura poder danificar os componentes eletrônicos. Portanto só utilize temperaturas mais altas se o que for soldado dissipar muito calor, como é o caso de soldas de fios de grande bitola, ou componentes PTH. Mesmo nesses casos se deve evitar temperaturas muito altas na estação.

Outra dica interessante é a seguinte. Muitas pessoas depois de utilizar a estação para uma solda, limpam a ponta da estação e a guardam em seu suporte, com a estação ainda ligada esperando a próxima solda. Eu mesmo sempre fiz isso e descobri que está errado. Depois de utilizar a estação, o correto é limpá-la e depois colocar estanho em sua ponta, e só depois recolocá-la no suporte. O estanho na ponta da estação serve para dissipar o calor, evitando que aquele calor se concentre na ponta danificando-a. Pois a ponta da estação aguenta as temperaturas de solda apenas quando existe uma carga térmica, ou seja, alguma coisa para dissipar o calor que ela produz. A carga térmica, quando soldamos, é tanto o terminal do componente a ser soldado como o estanho que colocamos no terminal. Depois que soldamos, retiramos os fatores que dissipavam calor e deixamos todo o calor na ponta, agredindo-a. Portanto após usar, limpe e coloque um pouco de estanho na ponta, para depois guardá-la no suporte.

Já se você é muito fanático pela sua estação e tem tempo de sobra, outra dica interessante é sempre que for deixar a estação ligada e em repouso, além de colocar estanho na ponta, abaixar a temperatura. É claro que, ao soldar, você deverá aumentar a temperatura e esperar o tempo de aquecimento da ponta. Mas dessa forma você garante uma vida útil grande para sua ponta de solda.

Outro hábito que é um erro é molhar demais a esponja vegetal que se utiliza para limpar a ponta. Essa esponja deve ser somente umedecida. Imagine a ponta da estação em uma temperatura de trabalho de 220°C tocando em uma superfície com temperatura ambiente (cerca de 25°C) e saturada de água, que dissipa muito calor. Isso faz com que a temperatura da ponta caia muito, e muito rapidamente. Essas variações bruscas de temperatura causam o que se chama de choques térmicos, o que diminui a vida útil dos materiais da ponta. Portanto, nada de molhar muito a esponja para aquela água durar uma semana.

Outro hábito errado com relação a limpeza da ponta na esponja vegetal é a forma de limpar. Muitas pessoas (inclusive eu novamente) tem a mania de limpar o 'ferro' da estação com ele deitado, para limpar também a lateral do ferro. Isso está errado. A única parte do ferro preparado para receber estanho é a ponta (por isso que o estanho só adere a ela) e, portanto, a única parte que deve tocar a esponja umedecida é a ponta. E a limpeza deve ser breve, nada de colocar a ponta por um longo período dentro da esponja. Eu fiz isso com uma ponta nova (estava ainda com o aspecto brilhoso) e ela saiu preta. Acredito que o que tenha acontecido seja a oxidação da ponta. Enfim, a ponta ainda funciona, mas, com certeza, perdeu parte de sua qualidade para solda.

Então por hoje é isso. Até a próxima e estudem muito. Eu mesmo estou estudando bastante sobre a parte de solda eletrônica (pois faz parte de meu trabalho) e, por isso, mais posts sobre isso deverão aparecer por aqui. Também continuarei com os posts sobre algoritmos e programação, principalmente agora que estou me atendo ao estudo de programação voltada a microcontroladores PIC. Se cuidem e cuidem também de suas estações de solda.

Qualquer dúvida, sugestão, elogios ou críticas, deixem um comentário. Fui.

Algoritmos e Programação - Um pouco sobre C

Olá a todos. Finalmente continuaremos com nossa série de programação e algoritmos em C falando do C em si. Eu gostaria de começar falando dos algoritmos sequenciais, mas sem entender o C, percebi que não seria possível começar a falar dos algoritmos. Agradecimentos a minha namorada que se propôs a ler meu post. Ontem completamos um ano de namoro! \o/ Obrigado Elen, te amo!

C é uma linguagem de programação muito famosa e que serviu de bases para outras linguagens de programação mais contemporâneas, como C++ e C# (lê-se C Sharp). Devido a ser uma linguagem muito usada na "construção" de outras linguagens, ela é geralmente a primeira a ser aprendida e é nela que aprenderemos nossas noções de algoritmos.

C foi desenvolvido por Dennis Ritchie e Ken Thompson em 1973 (considerei o fim do desenvolvimento com a adição do tipo struct, fonte Wikipédia) com o propósito de implementar o sistema Unix, que foi um dos primeiros sistemas que não foi implementado usando linguagem Assembly. Com o tempo foram acrescentadas outras características à linguagem C e, com isso, o C poderia divergir entre compiladores diferentes. Devido a isso foi estipulado o C ANSI, que é o "C mínimo", ou seja, o conjunto de comandos e funções mínimas que todo compilador de C considerado ANSI deve ter.

Para quem não sabe, ANSI significa American National Standards Institute, que é um órgão semelhante a ABNT (Associação Brasileira de Normas Técnicas) no Brasil.

Para começar nosso estudo de C, vou colocar um pequeno programa e, depois, detalhar seu funcionamento e os comandos e funções usados nele.

/*Começo do programa*/

#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

int nota_1, nota_2, nota_3, media;
main()
{
    printf("Digite a nota 1: ");
    scanf("%d",&nota_1);
    printf("Digite a nota 2: ");
    scanf("%d",&nota_2);
    printf("Digite a nota 3: ");
    scanf("%d",&nota_3);
    media=(nota_1+nota_2+nota_3)/3;
    printf("A media foi: %d.\n\n",media);
    system("pause");
}

/*Fim do programa*/

Primeiro, todo texto colocado entre /*  */ é um comentário. Comentários são textos que não entram para o código de programa, não são compilados e, portanto, não acrescentam tamanho no programa. Eles são muito importantes para que outros programadores e até o próprio desenvolvedor se entenda no meio do código. Embora neste pequeno programa eles pareçam desnecessários, em programas com mais de 1000 linhas eles são fundamentais. Outra forma de fazer comentários é usando barras duplas (//). Quando se usa barras duplas, todo texto daquela linha que se encontra após as barras duplas são considerados comentários. Essa característica foi implementada no C++ e ficou tão popular que a maioria dos compiladores C a utiliza. Porém cuidado! Essa forma de fazer comentários não faz parte do C ANSI, que utiliza apenas /* */. Caso seu compilador seja C ANSI, ou esteja configurado para entender somente C ANSI, utiliza apenas a forma /* */ para escrever seus comentários.

Após o primeiro comentário, existe uma linha #include . O comando #include manda o compilador incluir um arquivo ao seu programa. Esse arquivo pode ser uma biblioteca, como nesse caso. A biblioteca incluída foi stdio.h. Deixe-me explicar tudo de novo. A biblioteca stdio.h significa Standard I/O (entradas e saídas padrão). Nessa biblioteca estão definidas as funções que usamos durante o programa para ler o teclado (scanf) e para imprimir mensagens na tela (printf). A função da biblioteca é conter funções que utilizamos sempre e que, portanto, não queremos escrever em todos os programas que fizermos. A outra biblioteca, stdlib.h serve para permitir o uso do comando system("pause"), cuja funcionalidade explicarei mais adiante.

Depois do include temos a parte de declaração de variáveis. Uma variável é um espaço da memória que guarda um valor, um número binário. Temos também variáveis de vários tipos. No caso do programa acima, o tipo usado foi o int. Variáveis do tipo int ocupam, pelo padrão ANSI, 16 bits (2 bytes) e com isso representam números inteiros (SOMENTE INTEIROS) decimais de -32767 a 32766. Existem outros tipos de variáveis, mas, por enquanto, ficaremos somente com esse tipo. Na declaração de variáveis foram declaradas quatro variáveis, que se chamam nota_1, nota_2, nota_3 e media. Lembre-se que, dentro do código do programa, NÃO SE USA ACENTOS!!!

Após o include, existe a função main. A função main contém todos as funções e comandos que estão entre suas chaves que, neste caso, é todo o programa. A função main, que significa principal, existe em todos os programas e é basicamente por ali que o programa começa.

A primeira função do programa é a função printf, que imprime no dispositivo de saída padrão (a tela do computador) a mensagem colocada em seu argumento (dentro dos parênteses) entre aspas duplas. No caso do primeiro printf, a mensagem a ser mostrada é Digite a nota 1:.

A segunda função do programa é scanf. Essa função lê do dispositivo padrão (o teclado) o que foi digitado. Ela tem dois argumentos. O primeiro é "%d", que indica que o valor digitado será armazenado em uma variável do tipo inteiro, que é representado pelo %d. O segundo argumento, &nota_1, indica que o valor lido será armazenado na variável inteira que se chama nota_1. O operador & se refere a um ponteiro, que é o endereço da variável onde será armazenado o valor. Mas, por enquanto, esqueça isso. Lembre-se apenas que no scanf é necessário colocar & antes do nome da variável onde você quer armazenar o valor.

Após isso existem outros 2 printf e 2 scanf que fazem a mesma coisa que os anteriores, mas que armazenam valores na variáveis inteiras chamadas nota_2 e nota_3. Tanto a função printf quanto a função scanf estão declaradas dentro da biblioteca stdio.h, que nós incluímos ao nosso programa na primeira linha com o comando #include

Após os printf e scanf temos um cálculo matemático. Nessa parte, acredito que não existam maiores dificuldades no entendimento. Essa linha diz que a variável média recebe o valor da soma das três notas (nota_1+nota_2+nota_3) dividido por três, que é o cálculo da média aritmética.

Continuando, existe um último printf que vai mostrar o valor calculado da média na tela. Dentro do argumento entre aspas existe um %d. Já vimos no scanf que o %d se refere a uma variável do tipo inteira. Isso informa ao printf que ele irá mostrar na tela um valor numérico que está em uma variável inteira. Mas qual variável? Devemos informar ao printf o nome da variável cujo valor queremos mostrar na tela. Para isso colocamos o nome da variável fora das aspas duplas, separada por vírgula, como exemplificado no comando acima.

Dentro daquele printf também existe um \n (contra-barra n). Esse comando informa ao printf que é necessário pular uma linha, como se fosse um Enter no bloco de notas. No caso do programa acima, eu coloquei dois \n pois quis pular duas linhas. ;)

Por fim, o comando system("pause"). Ele está lá pelo seguinte motivo. Se você fizer o programa sem ele, o programa irá funcionar. Só que, imediatamente após calcular o valor da média e mostrar na tela, a janela do programa irá se fechar, sem dar tempo para você ler o que estava escrito nela. O comando system"pause") cria uma pausa no programa. Essa pausa dura até que você pressione alguma tecla. Então, se você já baixou o DevC++, copie e cole este programa simples lá, salve em algum lugar qualquer (como a área de trabalho) e compile ele. Para compilar, você pode usar a tecla de atalho (F9), ou ir em Execute->Compile.

Práticas (após conseguir fazer o programa funcionar):

1) Retire o ponto-e-vírgula (;) de algum dos comandos do programa e tente compilá-lo. Ele funciona? Coloque os ponto-e-vírgulas de volta.

2) Retire o & antes da variável no scanf. O programa continua funcionando? O que acontece? Após, coloque o & onde ele estava.

3) Substitua a linha do último printf (aquele que mostra o valor da média) pela linha de código abaixo. Compile o programa. O que aconteceu?

printf("nota 1:%d\nnota 2:%d\nnota 3:%d\nmedia:%d\n\n",nota_1,nota_2,nota_3,media);

4) Escreva suas dúvidas, sugestões e comentários nos comentários e me ajude a constuir o próximo post sobre Algoritmos e Programação. Espero no próximo post começar a falar dos algoritmos propriamente ditos, como algoritmos sequencias. Mas só poderei fazer isso se pelo menos o básico de C já estiver dominado. Então, continuem estudando e abraço. Até a próxima.