Sensor de Luminosidade com LDR - Parte 1

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Olá! a todos,

Neste post vamos aprender a trabalhar com o sensoreamento de LUZ, teremos uma grande quantidade de material para nos aprofundarmos , e no futuro fazer um projeto maior que é o ROBOT Seguidor de Linha.

Bom estudo!

Texto traduzido de http://www.ladyada.net/learn/sensors/cds.html, visitem!


LDR(Light Dependent Resistor)

Fotocélulas são sensores que permitem detectar a luz.
Eles são pequenos, de baixo custo, baixa potência, fácil de usar e não se desgastam.
Por esse motivo, muitas vezes aparecem em brinquedos, aparelhos e equipamentos.
Eles muitas vezes são referidos como células de CdS (eles são feitos de sulfato de cádmio).
São componentes cuja resistência é dependentes da luz incidentes (LDR), as chamadas fotorresistências ou  fotocélulas.

Então:
Fotocélulas são basicamente um resistor que muda seu valor de resistência (em ohms O) dependendo da quantidade de luz está brilhando sobre a sua face. Estes tipos de componentes de baixo custo são muitas vezes um pouco impreciso. Cada sensor de célula fotoelétrica actuará um pouco diferente do que o outro, mesmo se forem do mesmo lote.
As variações podem ser muito grande, 50% ou superior! Por esta razão, não devem ser utilizados para tentar determinar os níveis de luz precisos em lux ou millicandela. Em vez disso, você pode esperar apenas ser capaz de determinar mudanças básicas de luz.

Para a maioria dos projetos onde se necessita saber somente se temos "luz" ou "escuridão", ou se há algo na frente do sensor (que bloqueiam a luz), ou se há algo interrompendo um feixe de laser (os chamdos break-beam sensores), ou em alguns projetos saber dentre qual dos múltiplos sensores tem a luz mais forte; as fotocélulas pode ser uma boa escolha!

Como medir Luminosidade, usando um LDR

Como já dissemos, as mudanças de resistência em uma fotocélula depende de quanto ela está iluminada.
Quando a sua face esta no escuro, o sensor se parece com uma resistência muito grande de até 10MO, conforme aumenta-se o nível de luz, a resistência cai.
O gráfico abaixo indica aproximadamente a resistência do sensor a diferentes níveis de luz. Usar somente como um guia, pois cada fotocélula tem um comportamento e resistências diferentes!

Note-se que o gráfico não é linear, o gráfico é um log-log!

Fotocélulas, particularmente as células comuns CdS que você é provável encontrar, não são sensíveis a toda a luz. Em particular, eles tendem a ser sensíveis à luz entre 700nm (vermelho) e da luz 500nm (verde).

Muitos Datasheets usam o "lux" para indicar a resistência a certos níveis de luz.

Iluminância	Examplo
0.002 lux	Luar  numa noite de céu claro
0.2 lux	Design minimo para luz de emergencia (AS2293).
0.27 - 1 lux	Noite Limpa de lua cheia
3.4 lux	Limite de iluminação civil c/ céu limpo
50 lux	sala de estar familiar
80 lux	banheiro / entrada da casa
100 lux	dia nublado escuro
300 - 500 lux	nascer do sol ou por do sol em dia claro / escritório bem iluminado
1,000 lux	dia nublado, iluminação de estúdio de TV
10,000 - 25,000 lux	plena luz do dia (indiretamente para o sol)
32,000 - 130,000 lux	plena luz do dia (diretamente para o sol)

A maneira mais fácil de determinar se uma fotocélula esta funcinando é conectar um multímetro em seus terminais e medir a sua resistência com ela iluminada e sem iluminação. Apenas certifique-se de verificar que  as fotocélulas tem resistência entre 1MO e 1kO.

Devido fotocélulas serem basicamente resistências, elas não são polarizada. Isso significa que você pode conectá-los com os pinos independentes de polaridade positiva/negativa no circuito.

Medida com o LDR iluminado

Medida com o LDR sem iluminação

Como conectar seua fotocélula?

A maneira mais fácil de ligar  um sensor resistivo é conectar um terminal ao VCC e outro para um resistor de pull-down para o GND . Em seguida, o ponto situado entre a resistência de pulldown fixo e a fotocélula  é ligado à entrada analógica de um microcontrolador, tais como um Arduino.

Esquema de conexão

Diagrama Filiar

Para este exemplo estamos mostrando o uso de uma fonte de 5V, mas note que você pode usar também com uma fonte de 3.3V facilmente. Nesta configuração as gamas de tensão de leitura são de 0V (terra) a cerca de 5V (ou aproximadamente o mesmo que a tensão de alimentação).

A forma como isto funciona é que, como a resistência das fotocélulas diminue, a resistência total da célula foto-eléctrica e o resistor pulldown diminui a partir de 600KO para 10KO. Isso significa que a corrente que flui através de ambos os resistores, que por sua vez faz com que a tensão através do resistor fixo 10KO  aumente.

Luz ambiente como...	Ambient light (lux)	Photocell resistance (O)	LDR + R (O)	Current thru LDR +R	Voltage across R
Corredor	0.1 lux	600KO	610 KO	0.008 mA	0.1 V
Luar	1 lux	70 KO	80 KO	0.07 mA	0.6 V
Quarto escuro	10 lux	10 KO	20 KO	0.25 mA	2.5 V
Dia encoberto, quarto brilhante	100 lux	1.5 KO	11.5 KO	0.43 mA	4.3 V
Dia nublado	1000 lux	300 O	10.03 KO	0.5 mA	5V

Esta tabela indica que a tensão aproximada com base no sensor de luz / resistência / uma fonte de 5V e resistor pulldown 10KO.

Se você está planejando para que o sensor em uma área brilhante e usar um pulldown 10KO, ele vai rapidamente saturar. Isso significa que ele vai bater o "teto" de 5V e não ser capaz de diferenciar entre meio brilhante e muito brilhante. Nesse caso, você deve substituir o suspenso 10KO com um pulldown 1k. Nesse caso, não será capaz de detectar diferenças de nível escuro, bem mas será capaz de detectar diferenças de luz brilhante melhor. Esta é uma compensação que você terá que decidir!

Ambient light like…	Ambient light (lux)	Photocell resistance (O)	LDR + R (O)	Current thru LDR+R	Voltage across R
Moonlit night	1 lux	70 KO	71 KO	0.07 mA	0.1 V
Dark room	10 lux	10 KO	11 KO	0.45 mA	0.5 V
Dark overcast day / Bright room	100 lux	1.5 KO	2.5 KO	2 mA	2.0 V
Overcast day	1000 lux	300 O	1.3 KO	3.8 mA	3.8 V
Full daylight	10,000 lux	100 O	1.1 KO	4.5 mA	4.5 V

Esta tabela indica que a tensão aproximada analógico com base no sensor de luz / resistência w / uma fonte de 5V e uma resistência de 1K pulldown

Note-se que o nosso método não proporciona tensão linear relativamente ao brilho! À medida que aumenta o nível de luz, a tensão analógica sobe muito embora a resistência cai:

Vo = Vcc (R / (R + Fotocélula))

Isto é, a tensão é proporcional ao inverso da resistência da célula fotoeléctrica, que é, por sua vez, inversamente proporcional aos níveis de luz.

Bom! espero que toda esta teoria possa ajudar a compreender melhor o uso deste tipo de sensor.

No próximo post veremos a parte prática, então até lá!

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

Arduino, Termômetro

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Olá! a todos,

Neste post veremos como usar um Thermistor como componente de sensoreamento da temperatura ambiente.  E como usar o Arduino para adquirir as informações e visualizar isto em um display LCD 16 x 2.
Ajuste necessário: um termômetro digital para saber a temperatura do ambiente e assim ajustar o Arduino Termômetro.

O HARDWARE:
Para esta experiência necessitaremos de:
1 x Arduino UNO ou Duemilanove
1 x Bread Board
1 x LCD 16x2 I2C
1 x Thermistor de 10KO
1 x Potenciômetro de 50KO
Fios e Cabos


O CIRCUITO:

Ligar os pinos do LCD da seguinte forma:
GND ao negativo da alimentação
VCC ao positivo da Alimentação
SDA ligar ao pino analógico 4 do Arduino
SCL ligar ao pino analógico 5 do Arduino

O Thermistor deve ser ligado da seguinte maneira:
Um terminal do Thermistor deve ser conectado diretamente ao VCC, o outro terminal deve ser ligado ao pino 2 de um potenciômetro.
O pino central do potenciômetro deve ser ligado ao pino 1 dele mesmo, e o pino 1 deve ser conectado ao GND.
Na junção, entre o terminal do Thermistor e o pino 2 do potenciômetro, deve ser ligado o pino analógico 0 do Arduino.


                                  _                                ________
                                   \                              c|               |
VCC |---------------/\/\/\/\-------------2-/\/\/\/\-1-----+-------|GND
                                       \                           Potenciômetro
                                      Thermistor


Qual é a necessidade do potenciômetro?
O Thermistor é de 10 KO à temperatura ambiente de 25 Graus Celcius. Isso significa que se estivermos a 25 Graus Celsius, sua resistência terá exatamente 10KO e se colocarmos uma outra resistência fixa de 10KO como divisor de tensão, teremos metade do valor de VCC, ou seja 2,5V no pino analógico 0 do Arduino. Assim fica fácil parametrizar que quando tivermos 2,5V no pino analógico 0 , termos 25 Graus Celcius.
Como geralmente nosso ambiente não estará a 25 Graus Celcius, necessitamos do potenciômetro para saber qual resistência devemos colocar como divisor de tensão, e assim fazer um ajuste fino.
De posse de um termômetro digital (quanto mais preciso melhor), podemos fazer o ajuste;

Nota: se girarmos totalmente o POT em direção ao negativo o circuito nunca mostrará nenhuma temperatura.  Se quiser pode ser colocado um resistor de 5KO em série com o POT e assim ter um valor fixo e ajustar o valor somente dentro de uma faixa.

Existem dispositivos semicondutores que podem ser usados para medir a temperatura ambiente com maior precisão que um Thermistor, por exemplo o LM35,  ou o LM335, mas isto será tema de um outro post.

Vejamos o circuito feito em fritzing:

Arduino Termômetro - Esquema

O SOFTWARE:
Abaixo o software completo e comentado.
Visite para maiores informações; http://arduino.cc/playground/ComponentLib/Thermistor2


/*
  Este exemplo é um código de domínio público.
*/


#include <Wire.h> // inclui a biblioteca Wire


 #include <LiquidCrystal_I2C.h> // inclui a biblioteca do LCD

 // initialize the library with the numbers of the interface pins
 LiquidCrystal_I2C lcd(0x27, 16, 2); // inicalização do LCD com o endereço de 
                                     // pinos utilizados no Arduino
                                     
 //Código extraído de ...http://www.arduino.cc/playground/ComponentLib/Thermistor2

 #include <math.h> // inclui a biblioteca math

 double Thermister(int RawADC) { 
                                 // pega os dados lido do Thermistor quando chamada a função
                                 // e armazena em RawADC, este é um valor relacionado a
                                 // queda de tensão
 double Temp; // variável usada no cálculo
 Temp = log(((10240000/RawADC) - 10000));
                                         // relaciona o valor de queda de tensão lido com resistência
                                         // 10000 é o valor da resistência do Thermistor
                                         // se for necessário usar um Thermistor diferente
                                         // ajustar o valor corretamente

 // formula para dar a temperatura em Kelvin
 Temp = 1 / (0.001129148 + (0.000234125 * Temp) + (0.0000000876741 * Temp * Temp * Temp)); 
 Temp = Temp - 273.15;            // converte de Kelvin para Celcius

 return Temp; // retorna o valor da temperatura calculada
 }

 void setup() {
   // configura o LCD
   lcd.init();                           // inicializa o lcd 
   lcd.backlight();                  // com luz de fundo
   Serial.begin(9600);           // inicializa a comunicação serial
   // imprime mensagens no LCD
  
 }

 void loop() {
   
   lcd.clear();                                      // limpa o LCD
   lcd.setCursor(0,0);                         // posiciona o cursor na coluna 0 x linha 0
   lcd.print("Temp. Ambiente: ");         // texto para colocar significado ao que for apresentado
   lcd.setCursor(0,1);                        // posiciona o cursor na coluna 0 x linha 1
   lcd.print(int(Thermister(analogRead(0))));  // imprime o valor lido do thermistor correspondente
                                                                    // à temperatura
   lcd.print(" Graus C");                    // imprime a unidade medida
   delay(1000);                                // pausa até executar uma nova leitura e visualização
 }
 // Fim da Compilação



O VÍDEO:

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

Nesta experiência não teremos vídeo, pois ela é bem simples e está bem documentada.

Segue fotos do projeto.

Visão Geral

Temperatura no Display

Thermistor em azul

Pinagem

Até o próximo post, Bons experimentos!

Simon diz!

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Simon diz!? Sigam o mestre!

Excelente jogo da década de 80
Seguir uma sequência de luzes coloridas sinalizadas por sons foi uma fébre, este jogo rendeu milhares de dólares à Hasbro.

Ele procurava estimular a memorização através de cores e sons. De formato circular e com botões coloridos, o objetivo éra repetir as sequências sem errar e buscar a sequência mais longa.....

Verdadeiro Campeão.

No brasil, lançado pela Estrela, "Genius" foi o primeiro jogo eletrônico, uma versão da Americana Hasbro do jogo "Simon".

Hoje, imitado por muitos, em muitas tecnologias, tanto de hardware quanto de software.

Mais uma vez o Arduino, devido a sua versatilidade, pode trazer de volta a vida, com facilidade, este grande jogo.


O HARDWARE:

1 x Arduino Uno ou duemilanove
1 x Bread Board
1x Speaker 8O
1 x LED vermelho 3mm
1 x LED amarelo 3mm
1 x LED verde 3mm
1 x LED azul 3mm
4 x resistores de 220O
4 x botões dactilares
Fios e cabos

O CIRCUITO:

Ligar a cada LED com um resistor de 220O; ligar o terminal do resistor no anodo do LED e o catodo ligar diretamente ao terra.
Cada resistor deve ser ligado ao Arduino, a sequencia é:
LED vermelho - pino 8
LED amarelo - pino 9
LED verde - pino 10
LED azul - pino 11

As chaves devem ser ter um terminal ligado ao terra e o outro terminal diretamente ligado ao Arduino.
A sequência é:
chave correspondente ao vermelho - pino 2
chave correspondente ao vermelho - pino 3
chave correspondente ao vermelho - pino 4
chave correspondente ao vermelho - pino 5

O alto-falante deve ter o terminal negativo ligado ao terra e o positivo ligado diretamente ao Arduino no pino 12.

O SOFTWARE:

/*

Simon Says game. Now with sound effects. 
Originaly made by Robert Spann
Code trimmed and sound effects added by digimike


Os botões devem ser configurados para pinos designados sem resistores de pull down
 e conectados ao terra ao invés do +5. 
*/

#include <Tone.h>
Tone speakerpin; // gerador de tom para pino do speaker
// música de início
int starttune[] = {NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_F4, NOTE_G4};
int duration2[] = {100, 200, 100, 200, 100, 400, 100, 100, 100, 100, 200, 100, 500};
// música de acerto 
int note[] = {NOTE_C4, NOTE_C4, NOTE_G4, NOTE_C5, NOTE_G4, NOTE_C5};
int duration[] = {100, 100, 100, 300, 100, 300};

boolean button[] = {2, 3, 4, 5}; // pinos dos botões
boolean ledpin[] = {8, 9, 10, 11};  // pinos dos LEDs
int turn = 0;  // contador de vez
int buttonstate = 0;  // checagem do estado do botão
int randomArray[100]; //matriz para armazenar sequencia de acertos (longa..., ninguém chegou tão longe)
int inputArray[100];  


// na inicialização do Arduino
void setup() 
{
  Serial.begin(9600);
  speakerpin.begin(12); // speaker no pino 12

  for(int x=0; x<4; x++)  // pinos dos LEDs como saída
  {
    pinMode(ledpin[x], OUTPUT);
  }
  
  for(int x=0; x<4; x++) 
  {
    pinMode(button[x], INPUT);  // pinos dos botões como entradas
    digitalWrite(button[x], HIGH);  // habilita pull up interno; botões iniciam em estado alto; lógica reversa
  }

  randomSeed(analogRead(0)); // adicionado para gerar "mais aleatoreidade" 
                                                // com a matriz randomicapara a  função de saída
  for (int thisNote = 0; thisNote < 13; thisNote ++) { // toca música de início
     // toca a próxima nota
     speakerpin.play(starttune[thisNote]);
     // mantém a nota:
     if (thisNote==0 || thisNote==2 || thisNote==4 || thisNote== 6) // se estas notas?
     {
       digitalWrite(ledpin[0], HIGH);  // acende o LED vermelho (índice 0 da matriz, primeiro LED)
     }
     if (thisNote==1 || thisNote==3 || thisNote==5 || thisNote== 7 || thisNote==9 || thisNote==11) 
     // se estas notas?
     {
       digitalWrite(ledpin[1], HIGH); // acende o LED amarelo (índice 1 da matriz, segundo LED)
     }
     if (thisNote==8 || thisNote==12)
     // se estas notas?
     {
       digitalWrite(ledpin[2], HIGH); // acende o LED verde (índice 2 da matriz, segundo LED)
     }  
     if (thisNote==10) // se esta nota
     {   
       digitalWrite(ledpin[3], HIGH); // acende o LED azul (índice 3 da matriz, segundo LED)
     }
     delay(duration2[thisNote]); // pausa de cada nota
     // finaliza para iniciar a próxima nota
     speakerpin.stop();
     digitalWrite(ledpin[0], LOW); // apaga todos os LEDs
     digitalWrite(ledpin[1], LOW);
     digitalWrite(ledpin[2], LOW);
     digitalWrite(ledpin[3], LOW);
     delay(25); // pausa
    }
  delay(1000); // pausa
}


// loop principal do programa
void loop() 
{   
  for (int y=0; y<=99; y++)
  {
    // função para gerar a matriz a ser seguida pelo jogador
    digitalWrite(ledpin[0], HIGH); // acende todos os LEDs na inicialização
    digitalWrite(ledpin[1], HIGH);
    digitalWrite(ledpin[2], HIGH);
    digitalWrite(ledpin[3], HIGH);
  
    for (int thisNote = 0; thisNote < 6; thisNote ++) {
     // toca a próxima nota
     speakerpin.play(note[thisNote]);
     // mantém a nota; duração
     delay(duration[thisNote]);
     // finaliza para a próxima nota
     speakerpin.stop();
     delay(25); // pausa
    }
    
    digitalWrite(ledpin[0], LOW); // apaga todos os LEDs
    digitalWrite(ledpin[1], LOW);
    digitalWrite(ledpin[2], LOW);
    digitalWrite(ledpin[3], LOW);
    delay(1000); // pausa
  
// imprime o turno a sequência gerada, e a sequência do jogador
    for (int y=turn; y <= turn; y++)
    { // limitado pela variável de turno
      Serial.println(""); //saída serial com a sequência a ser seguida durante o jogo
      Serial.print("Turn: ");
      Serial.print(y);
      Serial.println("");
      randomArray[y] = random(1, 5); // designa um número randômico serial de (1-4) para um
                                                        //  randomArray[y], y inicia a contagem de turno
      for (int x=0; x <= turn; x++)
      {
        Serial.print(randomArray[x]);
      
        for(int y=0; y<4; y++)
        {
      
          if (randomArray[x] == 1 && ledpin[y] == 8) 
          {  // se está na matriz o que foi mostrado na posição 1?
            digitalWrite(ledpin[y], HIGH); // acende o LED
            speakerpin.play(NOTE_G3, 100); // toca nota
            delay(400); // pausa
            digitalWrite(ledpin[y], LOW); // apaga o LED
            delay(100); // pausa
          }

          if (randomArray[x] == 2 && ledpin[y] == 9) 
          { // se está na matriz o que foi mostrado na posição 2?
            digitalWrite(ledpin[y], HIGH);
            speakerpin.play(NOTE_A3, 100);
            delay(400);
            digitalWrite(ledpin[y], LOW);
            delay(100);
          }
  
          if (randomArray[x] == 3 && ledpin[y] == 10) 
          { // se está na matriz o que foi mostrado na posição 3?
            digitalWrite(ledpin[y], HIGH);
            speakerpin.play(NOTE_B3, 100);
            delay(400);
            digitalWrite(ledpin[y], LOW);
            delay(100);
          }

          if (randomArray[x] == 4 && ledpin[y] == 11) 
          { // se está na matriz o que foi mostrado na posição 4?
            digitalWrite(ledpin[y], HIGH);
            speakerpin.play(NOTE_C4, 100);
            delay(400);
            digitalWrite(ledpin[y], LOW);
            delay(100);
          }
        }
      }
    }
    input(); // chama função
  }
}



void input() { // funão para verificar as entradas do jogador contra a matriz gerada

  for (int x=0; x <= turn;)
  { // isto é controlado pelo contador de turno

    for(int y=0; y<4; y++)
    {
      
      buttonstate = digitalRead(button[y]);
    
      if (buttonstate == LOW && button[y] == 2)
      { // verifica se botão pressionado
        digitalWrite(ledpin[0], HIGH); // liga LED
        speakerpin.play(NOTE_G3, 100); // toca nota
        delay(200); // pausa
        digitalWrite(ledpin[0], LOW); // apaga LED
        inputArray[x] = 1; // 1 na variável do lugar da matriz (foi botão 1)
        delay(250); // pausa
        Serial.print(" "); 
        Serial.print(1);
        if (inputArray[x] != randomArray[x]) { // verifica valor de entrada do jogador e bate contra
          fail();                              // o valor no mesmo indice da matriz gerada
        }                                      // chama a função de falhou se não bater
        x++; // próximo
      }
       if (buttonstate == LOW && button[y] == 3) // se botão não pressionado e chegou a 3
      {
        digitalWrite(ledpin[1], HIGH); 
        speakerpin.play(NOTE_A3, 100); 
        delay(200); // pausa
        digitalWrite(ledpin[1], LOW); 
        inputArray[x] = 2;
        delay(250);
        Serial.print(" ");
        Serial.print(2);
        if (inputArray[x] != randomArray[x]) {
          fail();
        }
        x++;
      }

      if (buttonstate == LOW && button[y] == 4)
      {
        digitalWrite(ledpin[2], HIGH);
        speakerpin.play(NOTE_B3, 100);
        delay(200);
        digitalWrite(ledpin[2], LOW);
        inputArray[x] = 3;
        delay(250);
        Serial.print(" ");
        Serial.print(3);
        if (inputArray[x] != randomArray[x]) {
          fail();
        }
        x++;
      }

      if (buttonstate == LOW && button[y] == 5)
      {
        digitalWrite(ledpin[3], HIGH);
        speakerpin.play(NOTE_C4, 100);
        delay(200);
        digitalWrite(ledpin[3], LOW);
        inputArray[x] = 4;
        delay(250);
        Serial.print(" ");
        Serial.print(4);
        if (inputArray[x] != randomArray[x]) 
        {
          fail();
        }
        x++;
      }
    }
  }
  delay(500);
  turn++; // incrementa o contador de turno, 
          // como ultima ação antes chamar novamente a função de saída
}

void fail() { // função usada quando o jogador falha na sequência

  for (int y=0; y<=2; y++)
  { // pisca os LEDs para indicação de falha
    
    digitalWrite(ledpin[0], HIGH); // acende o LED
    digitalWrite(ledpin[1], HIGH);
    digitalWrite(ledpin[2], HIGH);
    digitalWrite(ledpin[3], HIGH);
    speakerpin.play(NOTE_G3, 300); // toca nota
    delay(200); // pausa
    digitalWrite(ledpin[0], LOW); // apaga LED
    digitalWrite(ledpin[1], LOW);
    digitalWrite(ledpin[2], LOW);
    digitalWrite(ledpin[3], LOW);
    speakerpin.play(NOTE_C3, 300); // toca nota
    delay(200); // pausa
  }
  delay(500); // pausa
  turn = -1; // reinicia o valor do turno então o jogo começa 
             // novamente sem necessidade de reset pelo botão
}

// Fim da Compilação



O VÍDEO:

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

Até o próximo!

Dado Eletrônico - LED Dice

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);

O dado eletrônico, é um simples brinquedo, onde você ao apertar um botão, gera números aleatório de 0 a 6, que serão mostrados em um conjunto de LEDs com o formato dos lados de um dado.

Mais uma demonstração de que com Arduino, qualquer tarefa se torna possível e pode ser executada com simplicidade e facilidade.

Exemplos de Dados com LED

O HARDWARE:

1 x Arduino UNO ou Duemilanove
1 x Push-botton/Switch Datilar
1 x Resistor de 10 KO
7 x Resistores de 220 O
7 x LEDs vermelhos
1 x BreadBoard
Fios

O CIRCUITO: 

Dado Eletrônico

Disposição dos LEDs
da direita para a esquerda
em cima:
LED1, LED2, LED3
em baixo:
LED4, LED5, LED6
no centro:
LED7

Disposição dos resistores

Disposição dos Fios

# 1

# 2

# 3

# 4

# 5

# 6

O PROGRAMA:

/*

  Este exemplo é um código de domínio público.
 */

// define os pinos onde conectados os LEDs
int ledPins[7] = {2, 3, 4, 5, 6, 7, 8}; 

// define o padão do LED, qual LED será aceso para cada número
int dicePatterns[7][7] = {
{0, 0, 0, 0, 0, 0, 1}, // 1
{0, 0, 1, 1, 0, 0, 0}, // 2
{0, 0, 1, 1, 0, 0, 1}, // 3
{1, 0, 1, 1, 0, 1, 0}, // 4
{1, 0, 1, 1, 0, 1, 1}, // 5
{1, 1, 1, 1, 1, 1, 0}, // 6
{0, 0, 0, 0, 0, 0, 0} // BLANK
};

int switchPin = 9; // define o pino do botão de 
int blank = 6; // quando cair Blank define como 6

// inicialização do Arduino
void setup()
{
  for (int i = 0; i < 7; i++) // gera loop para definição de pinos
    {
      pinMode(ledPins[i], OUTPUT); // define o pino (i) como saída
      digitalWrite(ledPins[i], LOW); // apaga o LED do pino (i)
    }
  randomSeed(analogRead(0)); // lê porta analógica 0 e gera um
                             // número aleatório
}

// loop principal do programa
void loop()
{
  if (digitalRead(switchPin)) // lê o estado do botão, se pressionado (1)(5V)
    {
      rollTheDice(); // roda o Dado
    }
  delay(100); // espera 100ms e executa novamente
}

// roda o Dado
void rollTheDice()
{
  int result = 0; // inicializa a variável "result" com 0
  int lengthOfRoll = random(15, 25); // gera comprimento da rodada, quantos números passarão
  for (int i = 0; i < lengthOfRoll; i++) // loop de 0 até comprimento da rodada
    {
      result = random(0, 6); // gera número de 0 a 6, devido ao indexda matriz começar em 0
                             // e ser preciso 7 números
      show(result); // mostra resultado
      delay(50 + i * 10); // atraso
    }
  for (int j = 0; j < 3; j++) // gera loop para piscar 3 vezes o resultado final
    {
      show(blank);  // mostra branco
      delay(500);   // espera 500ms
      show(result); // mostra resultado
      delay(500);   // espera 500ms
    }
}

// mostra o resultado nos LEDs
void show(int result)
{
  for (int i = 0; i < 7; i++) // gera loop para 7 resultados
    {
      digitalWrite(ledPins[i], dicePatterns[result][i]); // escreve no pino do LED (i) o resuldado de cada LED
    }
}

// Fim da Compilação


O VÍDEO:

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

Até o próximo Post!

Tradutor Morse

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Esta experiência é um complemento ao SOS, LED Código Morse.

Agora iremos ver como fazer um tradutor de palavras e textos para código morse e efetuar a sinalização em um LED.
Para usar, basta:
Abrir um terminal de comunicação serial da IDE do Arduino, e escrever os caracteres, palavra ou texto, e enviar. O Arduino irá traduzir e sinalizar no LED ou Lâmpada de Sinalização.

Tabela do Código Morse

O HARDWARE:
É o mesmo utilizado na experiência anterior. 

O CIRCUITO:

É o mesmo utilizado na experiência anterior.  Um LED ligado ao pino 10 com seu respectivo resistor de limitação e queda de tensão.



O SOFTWARE:

/*
  Este exemplo é um código de domínio público.
*/

int ledPin = 10; // pino onde seráconectado o LED

// matriz contendo o código Morse de cada letra do alfabeto
char* letters[] = {
".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", // A-I
".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-", ".-.", // J-R
"...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.." // S-Z
};

// matriz contendo o código Morse de cada número
char* numbers[] = {"-----", ".----", "..---", "...--", "....-", ".....", "-....",
"--...", "---..", "----."};

int dotDelay = 200; // delay para os "dits"

// inicialização do Arduino
void setup()
{
  pinMode(ledPin, OUTPUT); // define pino do LED como saída
  Serial.begin(9600); // inicializa a comunicação serial
}

// loop principal do programa
void loop()
{
  char ch; // define variável
  if (Serial.available()) // existe alguma informação a ser lida da serial?
    {
    ch = Serial.read(); // lê uma letra única
    if (ch >= 'a' && ch <= 'z') // se a letra estiver entre a e z
      {
      flashSequence(letters[ch - 'a']); // chama a função "flashSequence"
                                                     // tendo como parâmetro o número da
                                                     // letra na matriz
                                                    // subtrair 'a' da letra é um ponto
                                                    // de refrência 'a' - 'a' = 0...
                                                    // primeiro menbro da matriz;
                                                   // 'b' - 'a' = 1...
                                                   // segundo membro da matriz
                                                  // e assim por diante
      }
    else if (ch >= 'A' && ch <= 'Z') // se a letra está entre A e Z
      {
      flashSequence(letters[ch - 'A']); // como dito acima, agora para as maísculas
      }
  else if (ch >= '0' && ch <= '9') // se está entre 0 e 9
    {
      flashSequence(numbers[ch - '0']); // como dito acima, agora para os números
    }
  else if (ch == ' ') // se vazio, espaço
    {
    delay(dotDelay * 4); // gap entre as palavras
    }
  }
}

// pisca a sequência letras
void flashSequence(char* sequence)
{
  int i = 0;
  while (sequence[i] != NULL) // enquanto não acabar a sequencia de letras
    {
      flashDotOrDash(sequence[i]); // envia para ser piscado o dit ou dah 
      i++; // mais um da sequência
    }
  delay(dotDelay * 3); // gap entre letras
}


// pisca a sequência de dits e dahs
void flashDotOrDash(char dotOrDash)
{
  digitalWrite(ledPin, HIGH); // acende LED
  if (dotOrDash == '.') // se dit?
    {
      delay(dotDelay); // tempo de um dit
    }
  else // então é  um dah 
    {
      delay(dotDelay * 3); // tempo de um dah
    }
  digitalWrite(ledPin, LOW); // apaga o LED
  delay(dotDelay); // gap entre piscadas
}
// Fim da Compilação



O VÍDEO:
Vejamos o teste!

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

SOS, LED Código Morse

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Este projeto é mais um simples uso do Arduino, neste caso vamos gerar um Código Morse "SOS", que será mostrado em um LED ou, facilmente adaptável para uma Lâmpada de Sinalização.

SOS é um sinal usado em situaçãoes de emergência.  Quando enviado em CódigoMorse, consiste em três pontos (correspondente à letra S_, três traços (correspondentes à letra O) e novamente três pontos (. . . - - - . . .) - oralmente diz-se "dit dit dit   dah dah dah   dit dit dit" .
SOS pode significar:
"Save Our Souls" - Salve Nossas Almas;
"Save Our Seamens" - Salve Nossos Marinheiros;
"Save Our Ship" - Salve Nosso Navio;
"Survivor On Shore" - Sobreviventes na Costa;


O HARDWARE:
1 x Arduino UNO
1 x BreadBoard
1 x resistor de 220O 1/8W
1 x LED vermelho
Fios

O CIRCUITO:
Ligar o catodo do LED no negativo da alimentação;
Ligar um terminal do resistor ao anodo do LED;
O outro terminal do resistor ligar diretamente ao pino 10 do Arduino.

O SOFTWARE:

Abaixo o Software comentado das duas versões executadas

Primeira versão:


  Este exemplo é um código de domínio público.
 */

int ledPin = 10;  // pino onde será ligado o LED ou Lâmpada Sinalizadora

// matriz com a duração de piscadas para a palvra em Código Morse "SOS"
int durations[] = {200, 200, 200, 500, 500, 500, 200, 200, 200};


void setup() // inicialização do Arduino
  {
    pinMode(ledPin, OUTPUT); // configura o pino digital como saída
  }
  
void loop()  // loop principal do programa
  {
    for (int i = 0; i < 9; i++) // Loop iterativo das 9 piscadas do SOS
    {
      flash(durations[i]); // executa a função de piscar com a duração
                           // correspondente da matriz
    }
    delay(2000);   // espera 2 segundo e começa novamente
  }
  
// função para piscar o LED com uma certa duração  
void flash(int duration)
  {
    digitalWrite(ledPin, HIGH); // acende o LED
    delay(duration);            // espera a duração necessária
    digitalWrite(ledPin, LOW);  // apaga o LED
    delay(duration);            // espera a duração necessária
  }


Esta segunda versão têm a temporização de dits, dahs e separação entre caracteres de acordo com as normas internacionais:


  Este exemplo é um código de domínio público.
 */


int ledPin = 10;  // LED conectado ao pino 10


void setup() // inicialização do Arduino
{
pinMode(ledPin, OUTPUT); // configura pino do LED como saída
}

void loop() // loop principal do programa
{
// 3 dits
for (int x=0; x<3; x++) {
digitalWrite(ledPin, HIGH); // acende o LED
delay(150); // espera 150ms
digitalWrite(ledPin, LOW); // apaga o LED
delay(100); // espera 100ms
}

// delay de 100ms para ter um gap entre as letras
delay(100);

// 3 dahs
for (int x=0; x<3; x++) {
digitalWrite(ledPin, HIGH); // acende o LED
delay(400); // espera 400ms
digitalWrite(ledPin, LOW); // apaga oLED
delay(100); // espera 100ms
}

// delay de 100ms para ter um gap entre as letras
delay(100);

// 3 dits novamente
for (int x=0; x<3; x++) {
digitalWrite(ledPin, HIGH); // acende o LED
delay(150); // espera 150ms
digitalWrite(ledPin, LOW); // apaga o LED
delay(100); // espera 100ms
}

// espera 5 segundos antes de repetir o código de SOS
delay(5000);
}



O VÍDEO:

Vejamos os resultados!

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

LED Dimmer, via Processing

Esta barra, indica o nível de dificuldade encontrado para cada experiência realizada.
sendo:
"VERDE", indicação de nível 1 a 5 (Fácil);
"AMARELO", indicação de nível 6 a 8 (Médio);
VERMELHO, indicação de nível 9 e 10 (Difícil);



Esta experiência tem como objetivo mostrar o uso do "Processing" para controlar a intensidade do brilho de um LED.

O Funcionamento é o seguinte:

Via Processing Criamos um Applet com um gradiente variando de preto até branco e seus respectivos tons de cinza.
Ess applet é uma pequena caixa de 256 x 150 pixels, ao passar o mouse sobre a caixa, será enviado um byte (pela porta de comunicação serial) contendo a posição (eixo X) correspondente e assim um valor mapeado de 0 a 255, que será exatamente o valor de intensidade do brilho do LED.
O valor será recebido pelo Arduino (porta serial), processado, e enviado uma porta PWM, essa porta têm um LED conectado e o mesmo responderá ao comando de brilho, sendo:-
No processing, parte escura (preto), valor 0, LED apagado;
No processing, parte clara (branco), valor 255, LED acesso em pleno brilho;
No processing, partes variáveis (tons de cinza), valores diversos, brilho do LED com de acordo com o gradiente.

Página do Processing: http://processing.org/
Página do LED Dimmer: http://arduino.cc/en/Tutorial/Dimmer

O HARDWARE:

1 x Arduino UNO
1 x LED
1 x Resistor 220O 1/8W
1 x BreadBroard
Fios


O CIRCUITO:
Conectar um terminal do resistor ao Anodo do LED, o catodo do LED deve ser conectado diretamente ao negativo da alimentação.
O outro terminal do resistor deve ser ligado ao Arduino.

LED Dimmer - Fritzing

O SOFTWARE:
Abaixo o Software comentado para o Arduino e Processing.

Sketch Arduino LED Dimmer

Sketch do Processing

O VÍDEO:
Vejamos o resultado final.

Dúvidas e sugestões enviem para: arduinobymyself@gmail.com

CONCLUSÃO:

O Processing é uma grande ferramenta para interação entre Software e Hardware
Permite criar projetos fáceis e rápidos e de grande funcionalidade.