Osciloscópio de LED's

Este circuito permite a visualização das formas de ondas de sinais de baixa freqüência (até algumas dezenas de quilohertz) com uma definição que depende da qualidade de LEDs usados, no caso, 100 unidades.
O LM3914 funciona como um indicador de ponto móvel, onde o ponto desloca-se para cima e para baixo de acordo com a variação da intensidade do sinal aplicado à entrada.
Os ajustes são feitos em P¹ e P2 que estabelecem os limites desta execução em função da amplitude dos sinais que devem ser observados. Já os transistores T¹ e T² cada qual conduz em um ciclo de sinal, desta forma, o T¹, (PNP) quando conduz, derruba a tensão de 2,5 V ao um nível corresponde à amplitude do sinal, Enquanto T² (NPN) aumenta desta tensão acima dos 2,5 V presentes na entrada do LM3914 apresentando desta forma, as formas de onda do sinal já que o ponto zero é no centro, conforme ajustada a tensão em P¹.
A varredura junto com oscilação para cima e para baixo, faz com que o sinal de entrada seja “desenhado” na matriz de LEDs, isso através de um seqüencial com o circuito integrado 4017.
A freqüência de varredura é ajustada num potenciômetro de 47 Kº ligado a um astável com o conhecido circuito integrado 555. Veja que este oscilador não é gatilhado, de modo que o ajuste do ponto de varredura que permita uma melhor observação de um sinal. Um melhoramento para este projeto seria incorporar um oscilador gatilhado para está finalidade, caso em que uma imagem astável seria facilmente obtida.
Alimentação do circuito é feita com uma tensão de 5 V e os LEDs são todos comuns, vermelhos ou outra cor. Para melhor definição da imagem, eles devem ser montados o mais próximo possível.

Clique para Ampliar

VU Meter | 10 LED's | Muito Simples

Você Vai precisar de:
10 Leds
10 Transistores BC548
01 Transitor BD 135
10 Resistores de 1k
01 Resistor de 47Ohms
01 Resistor (Depende a Tabela Abaixo)
01 Resistor de 10k
11 Resistores 470Ohms
11 Diodos 1N4148
01 Capacitor 22uF
01 Fonte 12v DC
01 Transformador 110/6V de Baixa Corrente...

Estou trabalhando em uma placa de circuito impresso com um esquema muito mais elaborado e preciso, esqueminha profissional mesmo, quando terminar posto aqui no blog o tutorial passo a passo.

Testando Entradas USB e Fazendo uma Luminária USB

A cada dia surge mais um novo gadget ligado na USB e isso demanda um número maior de portas, logo, os gabinetes de hoje em dia estão vindo com mais portas USB em tudo que é canto, na frente, atrás, em cima, etc...
Essas USB frontais não são ligadas diretas à placa mãe, são uma extensão da mesma, e são muito fáceis de serem invertidas. Quanto mais USB, mais fácil a chance de ter portas invertidas.
Você não conhece ninguém que perdeu um pen-drive com USB invertida? Então, prazer. Eu já tive um pen-drive perdido dessa maneira.

Então, vamos ao que interessa, como fazer um teste de USB??

Funcionamento: As portas USB funcionam com 4 fios mas só precisaremos de dois, um de +5V e o outro de 0V(terra). Quando invertida a porta os fios são trocados e por isso queimam os dispositivos. O Teste de USB se baseia nisso daí, em duas luzinhas(leds); Normal ou Invertido. Lembre: NÃO usaremos os fios VERDES nem BRANCO.

Sugestão:
Leia nosso material sobre LED, Resistores, e Associação de Resistores para este "tutorial".



Material Para os Testes USB:
2 Resistores de 390R: R$0,05 cada
2 Leds (Verde e Vermelho): R$0,15 cada
1 Cabo USB(qualquer cabo que tenha USB): R$4,00 
1/5 Metro de cabo Termoretrátil: R$0,50
Solda, tesoura, ferro de solda, etc...
(obs: qualquer cabo usb serve)

Simulando: Usando o Proteus fiz uma simulação do circuito elétrico em duas posições, Normal e Invertida. Bem simples, mas se alguém não entender comenta aií que nós ajudamos.

	Esquema no Proteus 7

Montagem:
1) Corte o cabo USB do tamanho que lhe for viável (eu deixei uns 8 dedos pra usar ele como lanterna também) e descasque os dois fios de dentro. Lembrando das cores dos fios: +5V e TERRA.

	Cabo USB cortado

2) Corte um pouco as pernas dos resistores e leds (lembre que a perna maior é o polo positivo(+) do led) para não ficar tão grande.

	Resistores e leds cortados

3) Solde cada resistor a cada led (pode soldar em qualquer uma das pernas do led) e cubra com um pedaço do cabo termoretrátil (para fazer o isolamento das partes metálicas).

	Resistores soldados nos leds

4) Coloque pedaços do cabo termoretrátil nas pernas do led para organizar as partes metálicas e esquente um pouco (o cabo termoretrátil tende a contrair quando esquentado).

	Leds com cabos termoretrátil

5) Solde a perna MAIOR do led VERDE à perna MENOR do led VERMELHO.

6) Solde a perna MENOR do led VERMELHO à perna MAIOR do led VERMELHO.

7) Solde a perna MENOR do led VERDE ao fio PRETO.

8) Solde a perna MAIOR do led VERMELHO ao fio PRETO.

Obs: Lembre que você escolheu colocar o resistor em uma das duas pernas do led, logo, uma perna do led estará em um fio VERMELHO (ou PRETO) e a outra estará no resistor que por sua vez estará no fio PRETO (ou VERMELHO).

Feito isso, você deve estar com algo parecido com isso:


Se não quiser deixar os leds soltos, pode colocar umas espécia de invólucro para eles. No meu eu coloquei a capa de um plug do tipo banana e cola quente na ponta por questão de organização e proteção dos leds. Fica a gosto.


Se você tem medo de testar na USB então sugiro fazer um esquema na matriz de contatos (protoboard) antes de montar tudo:

	Teste com um led	Teste com um led (sem flash)

Inverta e veja se a luz verde apaga e a vermelha acende. Se der certo, faça e teste sem medo de ser feliz. Esse pequeno teste se torna em útil para aqueles que gostam de demonstar seus gabinetes e não têm certeza se ligou certo as USB frontais. Para técnicos e estudantes de hardware é uma mão na roda. Ou seja, não precisa de muito conhecimento de eletrônica, é bem simples, barato e ajuda pacas!

Você pode implementar o projeto usando LED's de Alto Brilho, que tem um pouco mais de corrente mas não afetam nada no caso deste circuito, talvez você tenha que alterar o resistor. 

Tendo um resultado final parecido com algum  destes,(idéia)...

Lembrando: Corrente Máx. do USB é 500mA, ou 0,5A então CALCULE antes de implementar o peojeto.

DICA: 

 Vfonte = 5v(USB); 

 Vled = Depende do seu LED; (COR)

 Iled = Corrente do seu led, recomento 20/25 para os LED's Normais.

Alarme de Intruso com Arduino

Nada como um alarme para alertar a presença de um intruso.
Apresento o projeto de Alarme que desenvolvi.
Este dispositivo gera um sinal sonoro e luminoso e um botão desarma o alarme.
O código desenvolvido para o projeto é fexível e  permite a interação com  outros tipos de sensores de presença com nenhuma ou minimas modificações. 

Para esse projeto não será exigido um conhecimento em eletrônica elevado, mas será preciso conhecer alguns conceitos mais avançados de programação para compreender com facilidade o que o código está fazendo.

Para esse projeto vamos precisar de:

1x Sensor de presença PIR
2x LEDs, um Verde e outro Vermelho. Ou um LED bicolor.
1x Buzzer
1x Resistor de 1k (é possivel usar valores direfentes)
1x Resistor 220R (é possível usar também valores de 100R a 10k)
1x Arduino (qualquer modelo)
1x Matriz de contatos e fios.


Prepare todo o material e monte na sua matriz de contatos como ilustrado abaixo:

Clicar na imagem para ampliar

Confira todas as conexões.
Note que os LEDs não são ligados ao GND do arduino.
Lembre-se que essa forma de controlar LEDs com arduino já foi elucidada em turoriais antigos .Bem como o botão e o buzzer.

1-Agora plugue o seu arduino no cabo USB e faça a gravação do código abaixo:

//Alarme Contra Intruso.

Descição:

Sensor detecta intruso e ativa sinal sonoro e luminoso. 

O alarme é desarmado pressionando um botão.

Luz Verde: Alarme está aguardando.

Luz Vermelha: Alarme detectou algo.

*/

int ledVermelho = 8;                 //Pino para o LED vermelho(RED)

int ledVerde = 7;                    //Pino para o LED verde(Green)            

int piezoPin = 6;                   // Pino para o + do PIEZO

int PIRPin = 4;                      //Pino OUT do PIR(leitura de valores)

int botaoPin = 5;                   //Pino de leitura da entrada do Botão

int PIR = 0;                     //Variável que representa o valor fornecido pelo sensor PIR

int Bot = 0;                        //Variável que representa o valor fornecido pelo Botão

void setup() {               //Declara LEDs e PIEZO como pinos de Saída. PIR e Botão como Entrada

  pinMode(piezoPin, OUTPUT);

  pinMode(ledVermelho, OUTPUT); 

  pinMode(ledVerde, OUTPUT);                                

  pinMode(PIRPin, INPUT);    

  pinMode(botaoPin, INPUT);

  }

void somAlerta() {                          //Função de nome: "somAlerta" que gera sinal sonoro

  digitalWrite(piezoPin, HIGH);

  delayMicroseconds(600);

  digitalWrite(piezoPin, LOW);

  delayMicroseconds(600);

}

void piscaLED(){                                   //Função de nome: "piscaLED" que gera sinal sonoro

 

  digitalWrite(ledVerde, LOW);                    // Pino do ledVerde será o Terra

  digitalWrite(ledVermelho, HIGH);             // Led Vermelho ON

  delay(100);

 

  digitalWrite(ledVermelho,LOW);                 // Led Vermelho OFF          

  delay(100);

}

void loop(){

 

  PIR = digitalRead(PIRPin);     // Faz leitura do OUT do senso PIR e joga o valor lido na variável: "PIR"

 

 

if (PIR == HIGH) {             // Testa se a variável "PIR" é alta(5v), caso SIM: executa uma tarefa Caso NÃO pular para else{

  do{                                     //Faça essa tarefa e testar em while

    digitalWrite(ledVermelho, HIGH);     // Liga led Vermelho

    digitalWrite(ledVerde, LOW);         // Pino do led Verde torna-se o GND(terra) do led Vermelho

     somAlerta();                        //chama função que emite um som de alerta

 

    Bot = digitalRead(botaoPin);      //Faz leiturado do Botão e joga o valor na variálvel "Bot"  

   

    }while(Bot==0);  //Enquanto a variável Bot for zero(Botão não pressionado) continuar  executando           

}     

else{                                // PIR não está HIGH então executa as tarefas que estão no else{

           if(Bot==1){                        // caso o botão for pressionado após o alarme disparar fazer uma tarefa

               for(int i=0; i<5 ;i++){            // Temporiza(alguns segundo) a função que será chamada "piscaLED()"

                 piscaLED();                   //chama função que pisca o LED vermelho

                 }

                

                 digitalWrite(ledVermelho, LOW);    

                 digitalWrite(ledVerde, HIGH);     // Liga Led verde para

                 delay(10000);                      // Aguarda 10s (impede um novo alarme de imediato)

                

               Bot=0;         //Após o temporizador chamar e executar a função pescaLED declara que a variável "BOT" é zero

           }

     

     

          digitalWrite(ledVermelho, LOW);     // Mantem o pino Vermelho como GND(terra) para o lede VERDE

          digitalWrite(ledVerde, HIGH);       // Led Verde ON

       

     

    }

   

   

}

Entendendo o código:

Temos dois blocos básicos: if e um else, que testam o estado do sensor PIR. Caso for ativado(HIGH) uma tarefa é executada indeterminadamente. Nesta execução uma função é chamada: somAlerta();   que ativa o sinal sonoro. E também o LED vermelho é ativado.
Caso o sensor PIR não detectar(LOW) nenhum intruso o else é executado. Tornando o Led Verde e aguardando a presença de um intruso.
Entretanto é feito um teste para saber se o alarme foi desativado a poucos instantes. Se isso for verdade uma função: piscaLED(); é chamada dentro de um temporizador para piscar o LED Vermelho por alguns segundos. Este comportamento informa que o alarme está sendo desativado pelo botão.
Passado esse tempo o LED fica Verde indicando que o sensor está monitorando a área.
Há também um "timer" que estabelece um tempo minimo de 10s para disparo do alarme após este ser desativado pelo botão.
É importante notar que o botão funciona corretamente quando pressionado.
O botão só é habilitado para desarmar o alarme após alguns segundos obrigando um aviso de alerta.
O sensor pode detectar uma pessoa até 7m de distância.


Vejam o vídeo do seu funcionamento:

Um muito interessante EMF Detector com Arduino...

Esse Detector de Atividade elétrica apartir de campos elétromagnéticos que se formam ao redor de condutores achei muito interessante, ja existe uma chave teste que criaram que faz isso, o interessante desse projeto em si é a sensibilidade e a criatividade pois ele usa o próprio condutor como "Sensor" de presença, pois CMOS é muito sensível, seria como um ruído de tensão que interpretasse esse sinal de campo elétromagnético e mostrasse na barra de LED's. Repare que no final do video ele fala que colocou a "antena" o condutor sensor muito perto do circuito de LED's e isso pode estar gerando uma interferência e/ou "microfônia"(acho que não mas é bom explicar) pois se o condutor liga um LED por um simples Pulso e o LED aumenta esse campo eletromagnético pois ele gera alguma atividade assim e o sensor o Lê denovo que acende mais um LED... dai pode até queimar, como isso não aconteceu deduzo eu que não foi o caso ah vá mas fica a dica!

Jeremy Blum Projects - Arduino Parte [3]

Esse é o Video da Semana [3]

Para quem não viu os outros ai vai o link:
Semana [1]
Semana [2]
Seria interessante assistir na ordem se você tem dificuldades em eletrônica, arduino...
Nesse video trataremos sobre:

-->Lei de Ohm
-->LED
-->Pull Up e Pull Down / Leituras I/O Digitais

Circuitos e Códigos Abaixo do Video:

Clique na Imagem para Aumentar

Esse primeiro circuito com código abaixo somente mostra que da Ruído pois qualquer pico mínimo de tensão como por exemplo o dedo encostado faria com que a entrada fosse interpretada como 1 ou seja ON, e sem dissipar esse ruído geraria varios problemas em circuitos seguintes e ou projetos compostos e complexos.

Clique na Imagem para Aumentar

Usando o Segundo Circuito Acima:

//Reads the State of a Button and displays it on the screen


int buttonPin = 8; //define pino 8 como buttonPin


void setup()
{
  //sets the button pin as an input
  pinMode(buttonPin, INPUT);  //define buttonPin como Entrada
 
  //Allows us to listen to serial communications from the arduino
  Serial.begin(9600); //comunicação com porta seria do PC
}


void loop()
{
  // print the button state to a serial terminal
  Serial.println(digitalRead(buttonPin)); // Lê pino 0 ou 1e mostra na tela do PC
  delay(1000);//espera 1 segundo para ler denovo
  //wait one second, then print again.
}

Jeremy Blum Projects - Arduino Parte [2]

Você que ainda não viu á parte 1 clique aqui!

Nesse Video trataremos sobre:

--> Saídas PWM e I/O
--> LED
--> Protoboard
--> Botões
--> ON/OFF Sem Ruídos







Código 1:

/*
Arduino Tutorials
Episode 2
Switch1 Program
Written by: Jeremy Blum
*/
int switchPin = 8;
int ledPin = 13;
void setup()
{
  pinMode(switchPin, INPUT);
  pinMode(ledPin, OUTPUT);
}
void loop()
{
  if (digitalRead(switchPin) == HIGH)
  {
    digitalWrite(ledPin, HIGH);
  }
  else
  {
    digitalWrite(ledPin, LOW);
  }
}


----------------------------------------------------------------------
 Código 2

/*
Arduino Tutorials
Episode 2
Switch Program
Written by: Jeremy Blum
*/
int switchPin = 8;
int ledPin = 13;
boolean lastButton = LOW;
boolean ledOn = false;
void setup()
{
  pinMode(switchPin, INPUT);
  pinMode(ledPin, OUTPUT);
}
void loop()
{
  if (digitalRead(switchPin) == HIGH && lastButton == LOW)
  {
    ledOn = !ledOn;
    lastButton = HIGH;
  }
  else
  {
    //lastButton = LOW;
    lastButton = digitalRead(switchPin);
  }
 
  digitalWrite(ledPin, ledOn);
}

----------------------------------------------------

Código 3;

/*
Arduino Tutorials
Episode 2
Switch3 Program (debounced)
Written by: Jeremy Blum
*/
int switchPin = 8;
int ledPin = 13;
boolean lastButton = LOW;
boolean currentButton = LOW;
boolean ledOn = false;
void setup()
{
  pinMode(switchPin, INPUT);
  pinMode(ledPin, OUTPUT);
}
boolean debounce(boolean last)
{
  boolean current = digitalRead(switchPin);
  if (last != current)
  {
    delay(5);
    current = digitalRead(switchPin);
  }
  return current;
}
void loop()
{
  currentButton = debounce(lastButton);
  if (lastButton == LOW && currentButton == HIGH)
  {
    ledOn = !ledOn;
  }
  lastButton = currentButton;
  digitalWrite(ledPin, ledOn);
}

----------------------------------------

Código 4;

/*
Arduino Tutorials
Episode 3
Switch4 Program (pwm)
Written by: Jeremy Blum
*/

int switchPin = 8;
int ledPin = 11;
boolean lastButton = LOW;
boolean currentButton = LOW;
int ledLevel = 0;

void setup()
{
  pinMode(switchPin, INPUT);
  pinMode(ledPin, OUTPUT);
}
boolean debounce(boolean last)
{
  boolean current = digitalRead(switchPin);
  if (last != current)
  {
    delay(5);
    current = digitalRead(switchPin);
  }
  return current;
}
void loop()
{
  currentButton = debounce(lastButton);
  if (lastButton == LOW && currentButton == HIGH)
  {
    ledLevel = ledLevel + 51;
  }
  lastButton = currentButton;
  if (ledLevel > 255) ledLevel = 0;
  analogWrite(ledPin, ledLevel);
}

Jeremy Blum Projects - Arduino Parte [1]

Achei esse cara pesquisando por ai ele cria VideoAulas toda semana sobre arduino e como criar coisas passo a passo muito simples e fácil.
Já esta na semana 11 mas eu colocarei aqui pouco à pouco por falta de tempo.
Para quem não entende inglês estarei explicando abaixo basicamente o que ele fez, mesmo sendo extremamente intuitivo o video não precisando necessariamente de tradução mas...

Episódio 1
Esse Episódio em específico trata sobre:

--> Arduino
--> LED
--> C/C++
--> Efeitos Pisca-Pisca (Blink no arduino.cc)

Após o video todos os código que precisara e circuitos:





/*
Jeremy's First Program
It's awesome!
*/

int ledPin = 13;

void setup()
{
  //initialize pins as outputs
  pinMode(ledPin, OUTPUT);
}

void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Sensor Simples de Proximidade +- 10CM

 Aqui desenvolvi um sensor bem simples que detecta aproximadamente,um objeto, a 10cm. Quando o sensor detecta algo o LED vermelho se apaga.  Veja abaixo mais detalhes:




Hardware Necessário:

>1 Placa Arduino
> Um LED InfraVermelho Transmissor
> Um LED Receptor Infravermelho
> Um LED Normal.



Código:

/* Programa para detectar distâcia de +-10cm e não sofre influência de outras fontes de luz,apenas do sol.
*/
int inPin = 7; // Diodo infravermelho TIL78 com filtro de luz(LED de cor negra)
int irPin = 11; // pino do LED emissor infravermelho(LED meio azulado)
int redPin=12; // LED normal de cor vermelha
int val = 0; // variavel lida no pino
void setup() {
pinMode(irPin, OUTPUT); // declare LED as output
pinMode(inPin, INPUT); // entrada do TIL78
pinMode(redPin, OUTPUT);
}
void loop()
{
val = digitalRead(inPin); // lendo valor  do TIL78
digitalWrite(irPin, HIGH); // o pino infravermelho esta sempre ligado
if (val == LOW) {          // é verdade quando tem algo no campo do ir(detectado) -- com luz o TIL78 gera "0"
digitalWrite(redPin, LOW); //  LED OFF
} else {  //se nao for "0"(LOW) vai ser "1"(HIGH) entao deve fazer: Ligar o LED vermelho.
digitalWrite(redPin, HIGH); //LED fica ligado ON
}
}

Controlando Display de 7 Segmentos com CD4511 e Arduino

Controlando Display de 7 Segmentos com CD4511 e Arduino

Depois de alguns dias  sem postar estou de volta com um projeto "cool". Hoje faremos um contador utilizando um display de 7 segmentos.
 

O display de 7 segmentos é normalmente utilizado para indicar números e podem ser vistos normalmente em elevadores, alguns rádio relógios.
Aqui está um exemplo de um display de elevador.



Material necessário:
Para este experimento precisaremos de alguns materiais:

- 1 Placa Arduino e seu respectivo cabo
- 1 Fonte de alimentação de 5V
- 1 Protoboard
- 7 resistores de 150Ω ($0,02 cada)
- 1 CI CD4511- Decodificador BCD - 7 Segmentos ($1,50)
- 1 Display de 7 Segmentos Catodo Comum ($0,50 cada)
- Alguns fios para conectar os componentes

O que faremos?

Criaremos um código para a placa Arduino, este enviará para um decodificador BCD-7-Segmetnos 4 bits, esses serão decodificados e então serão convertidos em 7 bits então usados para controlar um display de 7 segmentos.
Para saber mais sobre códigos BCD visite o link para a Wikipedia.

Como ligar os acessórios?

Neste post testaremos uma nova forma de mostrar como os acessórios foram ligados, apresentarei o circuito na forma de um desenho feito com com o software Fritzing que pode ser baixado gratuitamente do seu site. Veja na imagem a seguir como ficou o circuito ou clique aqui para ver em tamanho real.



Montagem:

Image do CI CD4511BE.


Conexão do CI, resistores e display de 7 segmentos. Ficou uma aranha. :)


Placa Arduino, responsável por enviar 4 bits em formato BCD.


Visão geral do projeto, protoboard, fonte, Arduino e componentes.


Programação:

A programação para este projeto é bem simples, defino 4 variáveis e atribuo a elas o endereço das portas de IO do Arduino. Em seguida na função Setup faço mais algumas configurações e então defino a função number que recebe um número como parâmetro. Baseado neste número as portas de saída são configuradas para enviar um valor BDC adequado.
Dentro da função loop crio 2 laços para fazer a contagem de forma crescente e depois decrescente. Bem simples, veja abaixo o código.

/*
7 Segments
This project uses the CD4511 BCD to 7segments Latch Decoder Driver
to count the numbers from 0 - 9 and after 1 second from 9 - 0.
*/
// Atribui a cada variável um endereço.
int pinA = 6, pinD = 7, pinC = 8, pinB = 9;
void setup()
{
// Configura a velocidade da porta serial
Serial.begin(9600);
// Diz ao controlador que os pinos são de saída
pinMode(pinA, OUTPUT);
pinMode(pinB, OUTPUT);
pinMode(pinC, OUTPUT);
pinMode(pinD, OUTPUT);
}
// Recebe um inteiro como parâmetro
// Baseado no número configura os pinos de saída conforme da tabela BCD
// do CI CD4511
void number(int num)
{
switch (num) {
case 0:
digitalWrite(pinA, LOW);
digitalWrite(pinB, LOW);
digitalWrite(pinC, LOW);
digitalWrite(pinD, LOW);
break;
case 1:
digitalWrite(pinA, HIGH);
digitalWrite(pinB, LOW);
digitalWrite(pinC, LOW);
digitalWrite(pinD, LOW);
break;
case 2:
digitalWrite(pinA, LOW);
digitalWrite(pinB, HIGH);
digitalWrite(pinC, LOW);
digitalWrite(pinD, LOW);
break;
case 3:
digitalWrite(pinA, HIGH);
digitalWrite(pinB, HIGH);
digitalWrite(pinC, LOW);
digitalWrite(pinD, LOW);
break;
case 4:
digitalWrite(pinA, LOW);
digitalWrite(pinB, LOW);
digitalWrite(pinC, HIGH);
digitalWrite(pinD, LOW);
break;
case 5:
digitalWrite(pinA, HIGH);
digitalWrite(pinB, LOW);
digitalWrite(pinC, HIGH);
digitalWrite(pinD, LOW);
break;
case 6:
digitalWrite(pinA, LOW);
digitalWrite(pinB, HIGH);
digitalWrite(pinC, HIGH);
digitalWrite(pinD, LOW);
break;
case 7:
digitalWrite(pinA, HIGH);
digitalWrite(pinB, HIGH);
digitalWrite(pinC, HIGH);
digitalWrite(pinD, LOW);
break;
case 8:
digitalWrite(pinA, LOW);
digitalWrite(pinB, LOW);
digitalWrite(pinC, LOW);
digitalWrite(pinD, HIGH);
break;
case 9:
digitalWrite(pinA, HIGH);
digitalWrite(pinB, LOW);
digitalWrite(pinC, LOW);
digitalWrite(pinD, HIGH);
break;
default:
digitalWrite(pinA, HIGH);
digitalWrite(pinB, HIGH);
digitalWrite(pinC, HIGH);
digitalWrite(pinD, HIGH);
}
}
void loop()
{
// Faz um loop de 0 a 9
for (int i = 0; i < 10; i++) {
// Imprime o valor desejado
number(i);
// Aguarda meio segundo
delay(500);
}
// Apaga o número, perceba que quando chamo a função number
// com um valor <0 ou >9 a função simplesmente apaga todos
// os leds do contador. Por isso, se chamo a função com o
// valor 10 simplesmente o display se apagará.
number(10);
// Aguarda 1 segundo
delay(1000);
// Faz um loop de 9 a 0
for (int i = 10; i >= 0; i--) {
// Imprime o valor desejado
number(i);
// Aguarda meio segundo
delay(500);
}
}

Botão sem ruído (Erros)

Este exemplo demonstra o uso de um interruptor como uma chave: cada vez que é pressionado, o LED (ou o que for) é ligado (se estiver desligado) e vice-versa. Além disso, também funciona como filtro para o ruído mecânico característico dos interruptores, sem o qual, ao pressionar o interruptor, detectaríamos uma seqüência de múltiplos toques. O código a seguir faz uso da função millis() para acompanhar o momento em que o interruptor é pressionado.

Circuito

O interruptor no pino 7 e o LED no pino 13.

Código

int inPin = 7;      // o número do pino de entrada
int outPin = 13;  // número do pino de saída

int state = HIGH;  // estado atual do pino de saída
int reading;       // estado atual do pino de entrada
int previous = LOW;  // estado anterior do pino de entrada

// as seguintes variáveis são do tipo ''long'' porque o tempo,
// medido em milissegundos,
// transformar-se-á logo em um valor grande demais para um ''int''
long time = 0;      // último momento em que o pino de saída foi atualizado
long debounce = 200 // tempo do filtro, aumente se ocorrer irregularidades

void setup()
{
  pinMode(inPin, INPUT);
  pinMode(outPin, OUTPUT);
}

void loop()
{
  reading = digitalRead(inPin);

  // se acabamos de pressionar o interruptor (isto é, se a entrada
  // foi de LOW para HIGH), e esperamos o bastante desde o
  // último toque de forma a ignorar o ruído...  
  if (reading == HIGH && previous == LOW && millis() - time > debounce)

 {
    // ... inverta a saída
    if (state == HIGH)
      state = LOW;
    else
      state = HIGH;

  // ... e lembre-se do momento do último toque
    time = millis();    
  }

  digitalWrite(outPin, state);

  previous = reading;
}

Controle um círculo de LEDs com um joystick

Circuito completo

Detalhe do cabeamento dos LEDs

Detalhe do cabeamento ao Arduino

Como funciona?

O joystick fornece coordenadas (x,y) ao Arduino de acordo com a sua posição. Como pode se ver, o espaço no qual o joystick se move é um círculo. Esse círculo será o que chamaremos de agora em diante de 'Torta' (veja a parte inferior direita da primeira imagem).
A única coisa que precisamos entender é que a Torta está dividida em 8 fatias. A cada fatia há um LED correspondente. (Veja a figura abaixo). Dessa forma, quando o joystick fornece-nos uma coordenada, ela necessariamente pertencerá a uma dessas fatias. O programa então acende o LED correspondente à fatia.

Código

 /* Controle_CírculodeLED_com_joystick
  * ------------
  * Este esboço controla um círculo com 8 LEDs
  * via joystick
  *
  * Primeiro lê-se os dois pinos analógicos conectados
  * ao joystick feito com dois potenciômetros
  *
  * Essa entrada é interpretada como coordenadas (x,y)
  *
  * Em seguida, calcula-se qual das 8 zonas possíveis 
  * faz parte das coordenadas (x,y)
  * 
  * Finalmente acende-se o LED que está na zona detectada
  *
  * @authors: Cristina Hoffmann and Gustavo Jose Valera
  * @hardware: Cristina Hofmann and Gustavo Jose Valera
  * @context: Arduino Workshop at medialamadrid
  */

  // Declaração de variáveis

  int ledPins [] = { 2,3,4,5,6,7,8,9 };

 // Matriz com 8 LEDs organizados em círculo
  int ledVerde = 13;
  int espera = 40;     // Tempo necessário para ligar o LED
  int joyPin1 = 0;   // variável deslizante conectada ao pino analógico 0
  int joyPin2 = 1;   // variável deslizante conectada ao pino analógico 1
  int coordX = 0;  // variável para ler o valor no pino analógico 0
  int coordY = 0;    // variável para ler o valor no pino analógico 1
  int centerX = 500;  // valor para a posição central do joystick
  int centerY = 500;
  int actualZone = 0;
  int previousZone = 0;

  // delegação dos pinos
  void setup()
  {
    int i;
    beginSerial(9600);
    pinMode (ledVerde, OUTPUT);
    for (i=0; i< 8; i++)
    {
      pinMode(ledPins[i], OUTPUT);
    } 
  }

  // função que calcula a inclinação da linha que passa pelos pontos
  // x1, y1 e x2, y2
  int calculateSlope(int x1, int y1, int x2, int y2)
  {
    return ((y1-y2) / (x1-x2));
  }

  // função que calcula em qual das 8 zonas possíveis
  // estão as coordenadas x, y dado o centro cx, cy
  int calculateZone (int x, int y, int cx, int cy)
  {
    int alpha = calculateSlope(x,y, cx,cy); 

// inclinação do segmento entre o ponto e o centro

    if (x > cx)
    {
      if (y > cy) // 1o quadrante
      {
        if (alpha > 1) // Inclinação > 1, portanto parte mais alta do 1o quadrante
          return 0;
        else
          return 1;    // Caso contrário, parte mais baixa do 1o quadrante
      }
      else // 2o quadrante
      {
        if (alpha > -1)
          return 2;
        else
          return 3;
      }
    }

    else
    {
      if (y < cy) // 3o quadrante
      {
        if (alpha > 1)
          return 4;
        else
          return 5;
      }
      else // 4o quadrante
      {
        if (alpha > -1)
          return 6;
        else
          return 7;
      }
    }
  } 

   void loop() {
    digitalWrite(ledVerde, HIGH); 

// flag para sabermos que se entrou em loop(), é opcional

    // leia o valor dos potenciômetros
    coordX = analogRead(joyPin1);   
    coordY = analogRead(joyPin2);   

    // calcule em qual x
    actualZone = calculateZone(coordX, coordY, centerX, centerY); 

    digitalWrite (ledPins[actualZone], HIGH);     

    if (actualZone != previousZone)
      digitalWrite (ledPins[previousZone], LOW);

   // imprima no terminal o valor cartesiano da coordenada
   // e a zona ao qual faz parte
   //não é necessário caso o Arduino rode em modo autônomo
    serialWrite('C');
    serialWrite(32); // imprima espaço
    printInteger(coordX);
    serialWrite(32); // imprima espaço
    printInteger(coordY);
    serialWrite(10);
    serialWrite(13);

    serialWrite('Z');
    serialWrite(32); // imprima espaço
    printInteger(actualZone);
    serialWrite(10);
    serialWrite(13);

  // Não apague a linha abaixo, ela é necessária!
    previousZone = actualZone;
   // delay (500);

 }