[vc_row][vc_column][vc_column_text]

O que é PWM?

Modulação por largura de pulso ou Pulse Width Modulation ( PWM ) é uma técnica que permite controlar a quantidade de energia fornecida a um determinado dispositivo eletrônico / elétrico. Basicamente o controle é obtido através da variação da largura de uma tensão retangular (DC) ao longo de um período de tempo. Quanto maior a largura do retângulo maior a potência na carga, a essa variação de largura, ou seja de tempo onde o sinal tem nível alto chamamos de duty cycle ou ciclo de trabalho.
Resumidamente o sinal PWM é uma onda digital retangular onde a frequência é constante e o tempo em que o sinal possui nível alto pode ser variado entre 0 e 100% (duty cycle).[/vc_column_text][vc_single_image image=”5425″ img_size=”full”][vc_column_text]Figura -1 Duty Cycle ou ciclo de trabalho. Fonte http://www.arduino.cc/en/Tutorial/PWM acessado em 28/07/2011[/vc_column_text][vc_column_text]

Controlando a luminosidade de um LED

Em uma ligação direta a uma bateria um LED emitirá uma boa quantidade de luz (é necessário limitar a corrente no LED com auxilio de um resistor), essa quantidade de luz pode ser diminuída ao se ajustar a quantidade de corrente fornecida ao LED, quanto maior a corrente, mais luz ele emitirá (lembro que existe um limite máximo de corrente que um LED suporta, consulte o datasheet de qualquer componente antes de utilizá-lo).
Para controlar a corrente pode-se mudar a resistência que é algo simples, mas nem sempre é algo prático, ou mudar a tensão, o que já é mais complicado. Contudo a principal desvantagem desses dois métodos é a perda de energia, quanto maior a tensão e corrente nos resistores maior é a perda P=U.I, sim essa perda é mínima se estivermos trabalhando com somente um LED, mas agora imagine um semáforo usando 80 LED`s por “bolacha”, agora imagine duzentos semáforos em uma cidade……….
O sinal PWM normalmente tem uma frequência fixa com um duty cycle que pode variar de 0% a 100%. Ajustando o duty cycle nós podemos facilmente controlar o brilho de um LED ou a velocidade de um motor.
A tensão média aplicada a um LED / resistor após o controle por PWM será proporcional ao ciclo de trabalho.
Tensão média = Duty Cycle * Vcc
Se tivermos um duty cycle de 50% e uam tensão aplicada de 5V a tensão média em cima de um led será de 2,5V
[/vc_column_text][vc_column_text]

PWM e o arduino

No Arduino Uno os pinos 3, 5, 6, 9, 10 e 11 podem ser usados para gerar um sinal PWM, podemos variar o duty cycle em até 256 passos ( 0 a 255 )
As frequências PWM padrões do arduino são:
Pinos 3, 9, 10 e 11 = 488Hz;
Pinos 5 e 6 = 976 Hz;
Não entrarei em detalhes , mas é possível alterar essas frequências. Para tal deve se configurar os  timers do arduino, porém algumas funções e bibliotecas poderão parar de funcionar após essas alterações, caso esteja interessado recomendo os seguintes links: http://www.arduino.cc/playground/Main/TimerPWMCheatsheet  acessado em 28/07/2011.
http://www.arcfn.com/2009/07/secrets-of-arduino-pwm.html  acessado em 28/07/2011.
http://arduino.cc/en/Tutorial/SecretsOfArduinoPWM  acessado em 28/07/2011.[/vc_column_text][vc_column_text]Um ótimo texto para ajudar a relembrar os conceitos sobre sinais elétricos pode ser encontrado em http://www.feiradeciencias.com.br/sala12/12_T12.asp acessado dia 26/07/2011.
Algumas das aplicações de um controle PWM seguem abaixo:
– Controlar a luminosidade de um LED;
– Gerar sinais de áudio;
– Gerar um sinal modulado;
– Controlar a velocidade de motores;
– Obter valores analógicos a partir de meios digitais;

Neste artigo vou mostrar como utilizar um arduino para controlar a luminosidade de um LED e a velocidade de um motor DC.[/vc_column_text][vc_column_text]

A função analogWrite()

Escreve um valor analógico (Onda PWM) em um pino. Pode ser usada para ligar um LED e variar sua luminosidade ou controlar a velocidade de um motor. Após chamar a função analogWite(), o pino irá gerar uma onda quadrada estável de frequência fixa (488Hz ou 976hz) sendo o duty cycle escolhido pelo usuário.
Sintaxe
analogWrite(pino, valor)

Parâmetros
pino: Número do pino que gerará o sinal PWM
value: Valor do duty cycle: deve ser um valor entre 0 (sempre desligado) e 255 (sempre ligado).

Notas e problemas conhecidos
Sugerimos evitar usar os pinos 5 e 6 pois os mesmos terão um duty cycle maior do que o experado, isto é devido as interações com as funções milis() e delay() que dividem internamente o mesmo timer usado para gerar o sinal PWM
[/vc_column_text][vc_column_text]

Montagem do circuito (Motor)

Materiais a serem utilizados:
1x Arduino
1x BD139 (ou outro transistor de potência)
1x Resistência de 100 Ohms
1x Potênciometro de 10K Ohms
1x Cooler de computador
1x Fonte 12 Volts[/vc_column_text][vc_single_image image=”5426″ img_size=”full”][vc_column_text] Figura 2 – Diagrama de montagem, não se esquecer de conectar os negativos juntos conforme mostra o esquema.[/vc_column_text][vc_single_image image=”5427″ img_size=”medium”][vc_column_text]Figura 3 – Pinagem do transistor BD139

[/vc_column_text][vc_single_image image=”5428″ img_size=”medium”][vc_column_text]Figura 4 – motor utilizado tensão 12V (cooler normal de computador)
[/vc_column_text][vc_single_image image=”5429″ img_size=”medium”][vc_column_text]Potênciomentro de 10k ohm[/vc_column_text][vc_column_text]O arduino possuí inúmeros pinos de saída e com eles podemos acionar diversos componentes como LEDs, displays de LCD, buzzers, sensores de temperatura etc. Entretanto para acionarmos cargas que demandam de mais potência os pinos de saída do arduino por muitas vezes podem não fornecer a corrente necessária além de corrermos o risco de queimarmos o arduino ao exigirmos dele correntes que ele não pode fornecer.

Para acionarmos essas cargas podemos utilizar os seguintes componentes:
– Relés
– Transistors bipolares
– Transistors de efeito de campo
– Triacs
– IC`s como o ULN2003
– Optoacopladores

Neste post entrarei em maiores detalhes sobre a utilização de um transistor bipolar, especificamente o BD139.

Como selecionar um transistor?

A corrente de coletor (Ic) que o transistor oferece deve ser maior do que a corrente que sua carga necessita, o transistor atuando como chave, ou seja em estado de saturação permite a passagem de corrente entre o Coletor e o emissor.
A corrente de base (Ib) deve ser calculada com intuito de deixar o transistor em estado de saturação. No datasheet do BD139 temos a seguinte informação:

Tensão de saturação entre Coletor e Emissor
(Ic=0,5 Adc, IB=0,05 Adc)[/vc_column_text][vc_column_text]A corrente de coletor no meu caso é de 0,2A (corrente consumida pelo meu cooler ligado diretamente aos 12V).
Como o datasheet nos diz que com IB de 0,05A podemos Ter um Ic de 0,5A que está acima das minhas necessidades posso considerar então a resistência de base como:

Rb = (V arduino)/Ic
Rb= (5 Volts)/0,05 = 100 Ohms

Outro fator importante ao se escolher um transistor para trabalhar com PWM a altas freqüências é evitar transistors com alto tempo de “base storage” ou seja que possuem um pouco de delay enquanto ele está chaveando ON / OFF, esse fenômeno é mais comuns em BJT`s de potência como o BD139 que utilizei. A freqüência utilizada neste projeto  fica em torno de 500 Hz e não resultará em nenhum problema.

Código Fonte (Motor)

#define TRANSISTOR 9
#define POT 1
int le_pot=0;

void setup()
{
pinMode(TRANSISTOR, OUTPUT);
}

void loop()
{
le_pot=(analogRead(POT))/4;
analogWrite(TRANSISTOR, le_pot);
}

[/vc_column_text][vc_video link=”https://www.youtube.com/watch?v=5c0-APqY2CY” el_width=”60″][vc_column_text]Vídeo 1 – Controle PWM de velocidade do motor utilizando[/vc_column_text][vc_column_text]Montagem do circuito (LEDs)

Materiais a serem utilizados:
1x Arduino UNO
3x LED`s
3x Resistência de 220 Ohms
1x Botão NA
1x Resistência de 10K Ohms[/vc_column_text][vc_single_image image=”5431″ img_size=”large” onclick=”img_link_large”][vc_column_text]Figura 6 – Diagrama de montagem.

Código Fonte (LEDs)
Este sketch consiste em fazer os 3 LED`s terem seu brilho aumentado a partir do acionamento do botão, ao atingir brilho máximo e se pressionar novamente o botão o processo é revertido e o brilho começa a decair.
Esse controle é feito dentro dos dois blocos de IF e o estado do botão é passado a duas variáveis distintas com intuito de controlar se é o primeiro acionamento ou o segundo.


//Exemplo de PWM com 3 LEDs R/G/B
// Efeito Fade com apertar de botão

#define LED_R 9
#define LED_G 10
#define LED_B 11
#define BOTAO 7
int i =0;
int var=0;
int antiga_var=0;

void setup()
{
pinMode(LED_R, OUTPUT);
pinMode(LED_G, OUTPUT);
pinMode(LED_B, OUTPUT);
pinMode(BOTAO, INPUT);
}

void loop()
{
var = digitalRead(BOTAO); // Lê o estado do botão pressionado = 1 solta = 0
delay(10); // Efeito de Debounce

if ((var==HIGH) && (antiga_var==LOW)){
// Efeito de aumento de brilho
for (i=0;i<255;i++)  // Conta de 0 a 255 e executa uma vez por contagem o conteudo entre{}  {  analogWrite(LED_R, i);   analogWrite(LED_G, i);  analogWrite(LED_B, i); delay(10); // Espera 10 mili segundos }  antiga_var = var;  var=LOW;  }  if ((var==HIGH) && (antiga_var==HIGH)){ // Efeito de aumento de brilho for (i=255;i>0;i–)
// Conta de 0 a 255 e executa uma vez por contagem o conteudo entre{}
{
analogWrite(LED_R, i);
analogWrite(LED_G, i);
analogWrite(LED_B, i);
delay(25); // Espera 10 mili segundos
}
antiga_var=LOW;
var=LOW;
}

}
[/vc_column_text][vc_video link=”https://www.youtube.com/watch?time_continue=1&v=CvzAZHBCFPc” el_width=”60″][vc_column_text]Vídeo 2 – Controle de LEDs utilizando PWM[/vc_column_text][/vc_column][/vc_row]

Aprimorando um projeto – Termômetro com registro de temperatura mínima e máxima

utilizando um display de LCD, leitura de temperatura exibindo resultado no computador e Leitura de temperatura exibindo resultado no LCD 

Faça a montagem da placa como mostrado no projeto de leitura de temperatura exibida no LCD,
este novo projeto somente implementa novas funções ao antigo e no final citará algumas dicas para tornar este projeto algo ainda melhor, podendo até servir de base para algum trabalho de conclusão de curso técnico.

Função para arredondar um valor lido.

 

Dúvidas em relação ao uso de funções? recomendo o seguinte site: 
http://www.inf.pucrs.br/~pinho/LaproI/Funcoes/AulaDeFuncoes.htm (acessado no dia 05/07/2011)


Se quisermos mostrar valores dentro de uma faixa pré determinada podemos tratar os valores lidos pelo sensor e estipular uma regra de controle.
Enviamos um valor a função (parâmetro) este valor será do tipo float portanto utilizaremos do seguinte estratagema para calcular somente o valor fracional.

Vamos supor que o sensor envia o seguinte valor para a função “30,25”
Decalaramos uma variável temporária do tipo int para armazenar o valor de 30,25
como a váriavel é do tipo int ela ignorará o valor fracional.


float arredondado=30,25;
int temp_aux=0;
arredondado=30,25;
temp_aux=arredondado; 


Ao lermos o valor da variável temp_aux leremos somente 30
Então para calcular somente o valor fracional faremos arredonda-temp_aux que seria (30,25)-(30)=0,25



 float arredondamento(float arredonda)
{
int temp_aux=0;
float temp_fracional=0;
float temp_final=0;
temp_aux=arredonda;
temp_fracional=(arredonda-temp_aux);

if (temp_fracional>=0.125 && temp_fracional<0.375)
{
temp_fracional=0.25;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}
}


O bloco IF acima testa se um valor é maior ou igual a 0,125 e menor que 0,375, se as duas condições forem satisfeitas a temperatura retornada terá um valor de 0,25 adicionada ao seu valor inteiro.

Exibindo valores mínimos e máximos no display LCD

Para exibir toda essa gama de valores precisaremos de um display de 20×4, caso você possua um display de somente duas linhas, altere o código para exibir somente os valores que desejar.

A grande pergunta que deve ser feita neste projeto é como descobrir e manter atualizado os valores mínimos e máximos de temperatura durante um período,  para realizar esse controle utilizaremos uma lógica condicional muito simples.
Primeiro devemos declarar duas variáveis que irão armazenar os valores máximos e mínimos definiremos um valor inicial para as mesmas que garantirão uma condição inicial verdadeira.

float temp_maxima=-150;  // valor muito BAIXO para condição de temp MAX
float temp_minima=300;  // valor muito ALTO para condição de temp MIN


Repare que as variáveis declaradas são do tipo float pois estas receberão valores reais fracionários dentro do laço de controle se a condição for verdadeira


 Bloco responsável por imprimir a temperatura máxima
    if (temp_maxima<valor_arredondado)
{
temp_maxima=valor_arredondado;
lcd.setCursor(0,2);
lcd.print(“Temp max: ” );
lcd.print(temp_maxima);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);
}


 Bloco responsável por imprimir a temperatura mínima

   if (temp_minima>valor_arredondado)
{
temp_minima=valor_arredondado;
lcd.setCursor(0,3);
lcd.print(“Temp min: ” );
lcd.print(temp_minima);
lcd.write(0); // Imprime o caractere º
lcd.print(C”);
} 


O funcionamento deste bloco de código segue a mesma linha do anterior, temp_minima terá um valor inicial muito alto o que garantirá uma condição inicial verdadeira, todo o controle de impressão no LCD e de posicionamento está no bloco do if para somente ser executado quando uma condição verdadeira for detectada, garantindo maior velocidade ao programa.

 Repare que como declaramos temp_maxima com o valor de -150 a primeira condição sempre vai ser verdadeira, por ser verdadeiros o laço do IF será executado e a variável temp_máxima receberá o primeiro valor enviado pelo programa e nas próximas execuções irá atualizar o valor somente se temp_maxima<valor_arredondado.
 

Código fonte

#define sensor 0
#include <LiquidCrystal.h>
/* Biblioteca com funcoes para uso de um LCD baseado no Hitachi HD 44780 */
LiquidCrystal lcd(1, 0, 5, 4, 3, 2); // deve ser colocada fora do setup() para valer em todos os blocos do programa
/* Define os pinos de ligação do LCD ao arduino com esta ordem LiquidCrystal(rs, enable, d4, d5, d6, d7)  */

float temp_maxima=-150;  // valor muito BAIXO para condição de temp MAX
float temp_minima=300;  // valor muito ALTO para condição de temp MIN

void setup()
{
//lcd.begin(cols, rows)
lcd.begin(20, 4); /* Tipo de LCD usado no meu caso de 20 colunas por 4 linhas */
lcd.setCursor(0, 0); /* O Cursor iniciara na coluna zero linha 0 */
lcd.print(”    Central AVR!”);

float le_temp(float x_sensor);
float arredondamento(float arredonda);
}

void loop()
{
byte a[8] = {  B01110,  B01010,  B01010,  B001110,  B00000,    B00000,  B00000,  B00000}; // Caractete criado
lcd.createChar(0,a); // define nosso caractere º como uma variável
float temperatura_lida, valor_arredondado;

// Bloco responsável por imprimir a temperatura atual
temperatura_lida=le_temp(sensor); //chama a função le_temp() e passa como parametro a variavel sensor
valor_arredondado = arredondamento(temperatura_lida); //chama a função arredondamento e passa como parametro temperatura_lida
lcd.setCursor(0,1);
lcd.print(“Temp atual: ” );
lcd.print(valor_arredondado);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);

// Bloco responsavel por imprimir a temperatura maxima
if (temp_maxima<valor_arredondado)
{
temp_maxima=valor_arredondado;
lcd.setCursor(0,2);
lcd.print(“Temp max: ” );
lcd.print(temp_maxima);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);
}

// Bloco responsavel por imprimir a temperatura mínima
if (temp_minima>valor_arredondado)
{
temp_minima=valor_arredondado;
lcd.setCursor(0,3);
lcd.print(“Temp min: ” );
lcd.print(temp_minima);
lcd.write(0); // Imprime o caractere º
lcd.print(“C”);
}
}

float le_temp(float x_sensor)
{
float temperatura=0;
float temperatura1=0;
float temperatura2=0;
float temperatura3=0;
float temperatura4=0;
float valor_lido=0;

valor_lido=analogRead(x_sensor); /* Lê tensao do LM35 */
temperatura1=(valor_lido*5*100)/1024; /* Conversao do valor lido */
delay(50); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
valor_lido=analogRead(x_sensor); /* Lê tensao do LM35 */
temperatura2=(valor_lido*5*100)/1024; /* Conversao do valor lido */
delay(50); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
valor_lido=analogRead(x_sensor); /* Lê tensao do LM35 */
temperatura3=(valor_lido*5*100)/1024; /* Conversão do valor lido */
delay(50); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
valor_lido=analogRead(x_sensor); /* Lê tensao do LM35 */
temperatura4=(valor_lido*5*100)/1024; /* Conversão do valor lido */
temperatura=(temperatura1+temperatura2+temperatura3+temperatura4)/4;
return temperatura;
}

/* Código responsável pelo arredondamento */
float arredondamento(float arredonda)
{
int temp_aux=0;
float temp_fracional=0;
float temp_final=0;
temp_aux=arredonda;
temp_fracional=(arredonda-temp_aux);

if (temp_fracional>=0 && temp_fracional<0.125)
{
temp_fracional=0.00;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.125 && temp_fracional<0.375)
{
temp_fracional=0.25;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.375 && temp_fracional<0.625)
{
temp_fracional=0.50;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.625 && temp_fracional<0.875)
{
temp_fracional=0.75;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}

if (temp_fracional>=0.875 && temp_fracional<1)
{
temp_fracional=1;
temp_final=(temp_aux+temp_fracional);
return temp_final;
}
}

Resultado final

 

Figura 1 – Display LCD 20×4 informando temperatura lida em um período.

 

Dicas para melhorar um projeto com termômetro.

Uma função adicional de fácil aplicação seria instalar um buzzer no arduino e disparar um alarme toda vez que uma temperatura pré determinada for atingida. Outra aplicação interessante mas um pouco mais complexa seria fazer um controlador de temperatura, onde se usaria uma resistência para gerar calor, existem duas maneiras simples de controlar a temperatura, a primeira seria controle ON/OFF e a segunda controle por PWM, lembrando que o arduino possui pinos dedicados a essa função.

 

 

byte a[8]= 

{

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

B11111,

}

lcd.createchar(0,a);

lcd.write(0);

A montagem segue o mesmo padrão dos artigos utilizando um display de LCD e leitura de temperatura. Porém combinaremos as duas.Para poupar o trabalho de consultar os artigos anteriores siga as imagens abaixo. Lembre-se de consultar o datasheet de seu Display LCD para conferir a compatibilade do seu módulo com o usado neste projeto.

 

O código

#define sensor 0
#include <LiquidCrystal.h>

/* Biblioteca com funcoes para uso de um LCD baseado no Hitachi HD 44780 */
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
/* Define os pinos de ligacaoi do LCD ao arduino com esta ordem LiquidCrystal(rs, enable, d4, d5, d6, d7)  */

float temperatura=0;
float temperatura1=0;
float temperatura2=0;
float temperatura3=0;
float temperatura4=0;
float valor_lido=0;

void setup()
{
/*lcd.begin(cols, rows) */
lcd.begin(20, 4); /* Tipo de LCD usado no meu caso de 20 colunas por 4 linhas */
lcd.setCursor(0, 0); /* O Cursor iniciara na coluna zero linha 0 */
lcd.print(”    Central AVR!”);

}
void loop()
{
byte a[8] = {  B01110,  B01010,  B01010,  B001110,  B00000,    B00000,  B00000,  B00000}; // Caractete criado
lcd.createChar(0,a); // define nosso caractere º como uma variável

valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
temperatura1=(valor_lido*5*100)/1024; /* Conversao do valor lido */
delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
temperatura2=(valor_lido*5*100)/1024; /* Conversao do valor lido */
delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
temperatura3=(valor_lido*5*100)/1024; /* Conversao do valor lido */
delay(100); /* Espera 100 mili segundos antes de prosseguir para a próxima medição*/
valor_lido=analogRead(sensor); /* Lê tensao do LM35 */
temperatura4=(valor_lido*5*100)/1024; /* Conversao do valor lido */
temperatura=(temperatura1+temperatura2+temperatura3+temperatura4)/4;

lcd.setCursor(0, 2); /* O Cursor iniciara na coluna zero linha 2 */
lcd.print(“Temperatura= “);
lcd.print(temperatura); // imprime no LCD o conteúdo da variável temperatura
lcd.write(0); // Imprime º na tela do LCD
lcd.print(“C”);
delay(600);
}

O resultado final

[vc_row][vc_column][vc_column_text]

Construindo um termometro com um LM35 e enviando a temperatura lida a um computador.

Nos artigos anteriores observamos que o arduino é capaz de detectar tensões aplicadas nos seus pinos e informá-las através da função digitalRead().
Porém este tipo de indicação é binário ou seja somente nos indica nível alto (5V) ou nível baixo (0V). Existem outros tipos de aplicações que necessitam de mais precisão e nos mostram tensões com maior índice de variações. Os componentes que são capazes de transformar variações físicas do ambiente (temperatura, pressão, umidade) em grandezas que podemos interpretar facilmente (tensão e corrente) são chamados de sensores.

Para facilitar a coompreensão vamos analisar o funcionamento de um LDR (do inglês Light Dependent Resistor ou em português Resistor Dependente de Luz).
O LDR é um tipo de resistor cuja resistência varia conforme a intensidade de radiação eletromagnética do espectro visível (luz) que incide sobre ele.
Um LDR é um transdutor de entrada (sensor) que converte a luz em valores de resistência. É feito de sulfeto de cádmio (CdS) ou seleneto de cádmio (CdSe). Sua resistência diminui quando a luz é muito alta, e quando a luz é baixa, a resistência no LDR aumenta. Um multímetro pode ser usado para encontrar a resistência na escuridão ou na presença de luz intensa. Estes são os resultados típicos para um LDR padrão:
• Escuridão : resistência máxima, geralmente acima de 1M ohms.
• Luz muito brilhante : resistência mínima, aproximadamente 100 ohms.
O LDR é muito frequentemente utilizado nas chamadas fotocélulas que controlam o acendimento de poste de iluminação e luzes em residências. Também é utilizado em sensores foto-elétricos assim como foto-diodos. (fonte wikipedia http://pt.wikipedia.org/wiki/LDR)
Vimos que um LDR varia sua resistência de acordo com a quantidade de luz que incide sobre ele, se fizermos uma montagem utilizando uma resistência fixa em série com um LDR criamos um simples divisor de tensão como visto na figura abaixo:

Na parte inferior direita da placa do arduino encontramos 6 entradas analógicas:
A0, A1, A2, A3, A4 e A5. Trata-se de pinos especiais que podem nos dizer exatamente qual a tensão aplicada a eles, sendo que para ler essa tensão usaremos uma nova função chamada de analogRead().
Esta função retorna um número entre 0 e 1023, que representa uma voltagem entre 0V e 5V. Por exemplo se uma voltagem de 2,5V é aplicada a uma das entradas analógicas o valor retornado pela função é de 512.

No mundo físico, parâmetros como temperatura, força, pressão, umidade, velocidade entre outros são sinais analógicos. Essas grandezas físicas são convertidas em sinais elétricos, sendo que, para podermos trabalhar com esses dados com o auxilio de micro controladores, devemos converter esses sinais usando um conversor analógico digital (ADC) que é um componente eletrônico que converte sinais para uma forma discreta. Os conversores analógicos digitais são os dispositivos mais usados no mundo para a aquisição de dados.

O sensor LM35 é um sensor de precisão, fabricado pela National Semiconductor
(www.national.com), que apresenta uma saída de tensão linear relativa à temperatura em
que ele se encontrar no momento em que for alimentado por uma tensão, tendo em sua saída um sinal de 10mV para cada grau Celsius de temperatura, sendo assim, apresenta uma boa vantagem com relação aos demais sensores de temperatura calibrados em “KELVIN”, não necessitando nenhuma subtração de variáveis  para que se obtenha uma escala de temperatura em Graus Celsius.
O sensor LM35 é apresentado com vários  tipos de encapsulamentos, sendo o mais
comum o TO-92, que mais se parece com um  transistor, e oferece ótima relação custo
benefício, por ser o mais barato dos modelos e propiciar a mesma precisão dos demais. A
grande diversidade de encapsulamentos se  dá devido à alta gama de aplicações deste
integrado.

Para uma variação de 1ºC o LM35 DZ gera uma tensão de saída de 10mV, se a temperatura ambiente for de 23ºC a saída do LM35 será de 0,23V ou 230mV (23*10mV).
O LM35DZ é capaz de indicar temperaturas de 0ºC a 100ºC este tipo de informação é importante pois ao trabalharmos com sensores e conversores analógicos para digitais (ADC) temos que saber o fim de escala isto é o último valor informado pelo sensor e sua tensão final de saída.
Neste caso o LM35 DZ se mostra de fácil entendimento pois 100ºC equivale a 1V (100*10mV), o ADC do arduino trabalha normalmente com um fundo de escala de 5V então teremos que nos ajustar para esse requisito, o que pode ser feito via software ou hardware.
O foco deste artigo é tomar sempre o caminho mais simples, portanto seguirei com o ajuste por software, mas darei uma dica sobre o ajuste por hardware, procure na internet ou na própria referência do arduino o ajuste de valor de referência do ADC.

Mais sobre o LM35 em http://hermes.ucs.br/ccet/demc/vjbrusam/inst/temp51.pdf acessado em 24/07/2011

O fundo de escala do LM35 DZ é de 100ºC ou 1V que é exatamente 5 vezes menor que a tensão de referência, portanto para termos uma leitura padrão faremos o valor lido vezes 5 vezes 100, e dividiremos o resultado por 1024 que é o número de retorno da função para termos um valor de retorno unitário. Assim corrigimos o fundo de escala e temos um valor de saída conhecido.

Agora vamos comprovar teoricamente a eficiência da conversão.
10mV é o passo unitário do sensor ou sua sensibilidade
5V é a tensão de referência do ADC que possui resolução de 10 bits (2^10 = 1024).
5V/1024 = 0,00488 que é a sensibilidade do ADC.

Para 1ºC temos:
valor lido = 10mV/0,00488 = 2,04 como esse resultado será armazenado em valor_lido uma variável do tipo int valor_lido será igual a 2.
Agora faremos os ajustes de fundo de escala e de conversão fisíca que se resume a uma simples multiplicação por 500 (5*100*valor_lido)

Resultado final

(Valor_lido *5 *100)/1024

(2*5*100)/1024 = 0,97ºC como nosso resultado sera apresentado como número inteiro teremos exibido 1ºC

Para 100ºC temos:
100ºC retorna o valor 1023 pela função analogRead; (que vai de 0 a 1023 no total 1024 passos )
como temos um valor 5 vezes menor devido a discrepância entre as referências teremos o seguinte
valor_lido= 1023/5 = 204,6

A conversão D/A (digital / analógica) ou A/D (analógica / digital) gera ou utiliza um sinal digital composto por bits. A quantidade  de bits utilizada pela palavra digital na conversão determina o que é chamado de resolução. Quanto maior a resolução de uma interface, mais exata será sua percepção em relação aos sinais analógicos externos e mais precisa será sua representação digital.
De acordo com a ANALOG DEVICES resolução é o número de bits que o ADC utiliza para
representar o sinal analógico. Quanto maior a resolução, maior o número de divisões em que a faixa do sinal será representada, sendo assim quanto maior a resolução mais sensível é o ADC para as variações de tensão em uma mesma faixa de entrada e ganho. A menor variação de tensão detectável (também chamada de largura de código – code width) para um dispositivo de aquisição de dados  ideal é determinada por:

Para este artigo o resultado será exibido na tela de seu computador, a partir do protocolo de comunicação serial.
O arduino pode tanto receber comandos de um computador como também enviar. Para este objetivo iremos utilizar um objeto serial ( um objeto é uma coleção de habilidades que são postas juntas para a conveniência das pessoas que escrevem os códigos ou sketches).
Este objeto contém todo o código necessário para o envio/recebimento de dados.
A função para escrever dados serialmente é a Serial.println, mais informações sobre a mesma podem ser encontradas na pasta de referência do arduino.
Para habilitar a visualização dos dados envidos serialemtne pelo arduino, clique no ícone “Serial Monitor” e configure a taxa de transferência para 9600 baud.

#define sensor 0

int temperatura=0;
int valor_lido=0;

void setup()
{
Serial.begin(9600);
}
void loop(){
if (Serial.available())
{
valor_lido=analogRead(sensor);
temperatura=(valor_lido*5*100)/1024;
Serial.println((long)temperatura);
}
delay(1000);
}

Para visualizar o valor lido clique no campo para entrada de dados do serial monitor e aperte ENTER, se tudo ocorreu perfeitamente um valor de temperatura será enviado pelo arduino, no meu caso em um dia chuvoso a temperatura lida foi de 21ºC

[/vc_column_text][/vc_column][/vc_row]