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);
Arduino by my Self
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
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
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
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.
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.
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 têm como objetivo, mostrar um uso prático do Arduino.
Um sistema de segurança para fazer o controle de acesso, por exemplo, da entrada de pessoas a um determinado ambiente seguro.
O sistema consta de um teclado para a entrada de uma senha, e um display LCD para visualizar mensagens.
A simulação é feita com LEDs, porém facilmente implementado para relés ou solenóides.
Como funciona:
Ao iniciar o sistema, um LED vermelho indica que o sistema está pronto, e neste caso não adianta digitar números no teclado, pois os mesmos não será processados; a não ser a tecla "#", que indicará ao sistema que alguém irá digitar uma senha.
Ao digitar "#"o sistema libera o teclado para a entrada da senha, e um LED amarelo sinaliza esta funcionalidade, bem como, será mostrado uma mensagem no display informar ao usuário que é necessário digitar a senha.
Digitando números no teclado (para cada um será emitido uma sinalização acústica), o sistema processará os dados.
Se a quantidade de números digitar for igual a 4 e corresponder exatamente a senha do sistema, então será habilitato o relé ou o solenóide de acionamento (indicado por um LED verde, que irá piscar por cerca de 5 segundos, e o sistema estará liberado; durante esse período um som será emitido para sinalização; uma mensagem será mostrada no display, para informar ao usuário que o acesso foi liberado).
Se a quantidade de números digitados for 4 e não corresponder a senha esperado para o sistema, então o sistema não será liberado e voltará ao estado inicial. O mesmo acontece se for pressionado a tecla "#" novamente.
O HARDWARE:
1 x Arduino UNO
1 x Teclado numérico 3x4
1 x Display LCD 2x16 I2C
1 x Buzzer
1 x Breadboard
4 x Resistores de 220O 1/8W
1 x LED verde 3mm
1 x LED Amarelo 3mm
1 x LED Vermelho 3mm
Fios e cabos para conexões
O CIRCUITO:
Utilize a breadboard para fazer as ligações:
Mini BreadBoard
BreadBoard
Para cada LED associar um resistor de 220O em série conectado ao terminal Anodo e o terminal catodo ligado diretamente ao negativo da alimentação. O outro terminal do resistor vai ligado ao Arduino, conforme abaixo:
Para o LED verde, terminal do resistor ligado ao pino 10
Para o LED amarelo, terminal do resistor ligado ao pino 11
Para o LED vermelho, terminal do resistor ligado ao pino 12
Para o Buzzer, associar um resistor de 220O ao teminal positivo, sendo o terminal negativo do mesmo, ligado ao negativo da alimentação. O outro terminal do resistor deve ser ligado ao pino 9 do Arduino.
Tipos variados de Buzzers
Buzzer soldável em placa
O teclado deve ser ligado da seguinte maneira:
Linha 1, ligada ao pino 5 do Arduino
Linha 2, ligada ao pino 4 do Arduino
Linha 3, ligada ao pino 3 do Arduino
Linha 4, ligada ao pino 2 do Arduino
Coluna 1, ligada ao pino 6 do Arduino
Coluna 2, ligada ao pino 7 do Arduino
Coluna 3, ligada ao pino 8 do Arduino
Detalhe da conexão flexível linhas x colunas
Teclado 4x3 flexível
Display I2C
Ligar o Vcc do dispositivo ao positivo da alimentação
Ligar o GND do dispositivo ao negativo da alimentação
Ligar o SDA do dispositivo ao pino A4 (analógico 4) do Arduino
Ligar o SCL do dispositivo ao pino A5 (analógico 5) do Arduino
Detalhe do adaptador I2C
Display I2C com BackLight azul e caracteres brancos
Diagrama:
Diagrama em fritzing
O Display LCD utilizado é um display I2C.
O SOFTWARE:
Abaixo o Software utilizado, com todos os comentários necessários (veja também o vídeo).
Este projeto foi baseado no projeto do Marcelo Rocha
Dúvidas e sugestões enviem para: arduinobymyself@gmail.com
Bom!, espero ter mostrado, o quanto o Arduino é flexível, fácil e dinâmico na realização de projetos.
Até o próximo post.
Como muitos visitantes pediram: Agora temos uma Atualização do Sistema de Segurança com Arduino. Sendo possível entar como uma nova senha via teclado. Lembrando que ela permanece enquanto o sistema estiver ligado (em caso de perda de energia, a senha volta para a senha padrão). ;-) Abaixo o código completo e uma nova versão da biblioteca LCD via I2C para a IDE 1.0 e da biblioteca keypad
Agora com LCD normal 16x2 e LCD I2C, no mesmo SW você pode escolher entre um e outro somente tirando o comentário de algumas linhas; Lendo e gravando as passwords diretamente na EEPROM do arduino; Agora o sistema não perde mais a password em caso de ser desernergizado; Conhecendo o password antigo, é possível configurar um novo password que será gravado na EEPROM; Para efeitos mais práticos de simulção, foi adicionado um servo-motor para fazer o acionamento da tranca; Os comentários e as Telas do SW agora estão no idioma Inglês (devido a esse projeto estar também hospedado em sites estrangeiros; quando digitado o password, um máscara com * irá aparecer para não divulgar os números (somente para efeitos especiais, pois os numeros do password não são mostrados enquanto digitados); Nessa nova edição o teclado foi alterado para o tamanho 4x4, ou seja as senhas agora podem ter letras e números, o comprimento da senha também pode ser alterado na programação inicial do sistema. Foi acrescentado um RTC Real Time Clock, para mostrar a hora no display na tela principal. Conta com um temporizador; caso a pessoa não entre a senha correta em 5 segundos, volta para a tela inicial.
Dessa forma algumas mudanças na pinagem e interconexão foram necessárias; siga no próprio software a pinagem para as conexões do sistema.
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 tutorial tem como objetivo mostar o uso do PWM para controlar o brilho de um LED causando efeito de desvanecimento contínuo da luz emitida.
Usaremos a função analogWrite() para escrever um sinal com modulação por pulso no LED; esta função comuta um sinal "on" "off" rapidamente no pino digital, com diferentes proporções, causando o efeito de "fading".
Vamos fazer um parenteses para entender melhor o PWM.
(
Modulação largura, ou PWM, é uma técnica para obter resultados analógicos com meios digitais.
O controle digital é usado para criar uma onda quadrada, um sinal alternado entre ligada e desligada.
Este padrão on-off pode simular tensões entre plenos (5 volts) até (0 volts), alterando a porção do
tempo que o sinal passa ligado em relação ao tempo que o sinal passa desligado.
A duração de "tempo" é chamado de largura de pulso.
Para obter diferentes valores analógicos, você muda, ou modula, a largura de pulso.
Se você repetir esse padrão on-off rápido o suficiente com um LED, por exemplo,
o resultado é como se o sinal fosse uma tensão estável entre 0 e 5v, controlando o brilho do LED.
No gráfico abaixo, as linhas verdes representam um tempo regular, um período.
Esta duração ou período é o inverso da frequência de PWM.
Em outras palavras, como a freqüência de PWM do Arduino é cerca de 500Hz,as linhas verdes mediriam 2 milissegundos cada.
Uma chamada para analogWrite () é uma escala de 0 - 255; analogWrite(255) indica que se solicita um ciclo de trabalho de 100%
ciclo (sempre ligado), e analogWrite (127) é um ciclo de 50% (metade do tempo), e assim por diante.
1 x Placa Arduino UNO
1 x Resistor 220O
1 x LED
1 x Breadboard
Fios
O Circuito:
Imagem gerada usando Fritzing, Visite o site oficial para download e tutoriais: http://fritzing.org/
Usando a Breadboard:
Connecte o terminal "Anodo" do LED ao resistor;
O terminal "Catodo" do LED, conecte ao negativo da alimentação;
O outro terminal do resistor, conecte ao pino 9 do Arduino.
O Programa:
Abaixo o código comentado.
/* Fade
Este exemplo mostra como desvanecer um LED conectado ao pino 9 usando a função analogWrite().
Este código é de domínio público. */
int brightness = 0; // quantidade de brilho do LED int fadeAmount = 5; // quantos pontos o LED irá desvanecer
//inicialização void setup() { pinMode(9, OUTPUT); // declara o pino 9 como saída }
//programa inicial void loop() { analogWrite(9, brightness); //determina o brilho do LED brightness = brightness + fadeAmount; // troca o brilho para a próxima iteração do loop if (brightness == 0 || brightness == 255) { // reverte a direção do desvanecimento ao fim do mesmo fadeAmount = -fadeAmount ; } delay(30); // espera 30 milisegundos para ver o efeito de escurecimento }
