O capacitor de fluxo é o principal componente da máquina do tempo construída pelo Doutor Brown. É o componente responsável por tornar a viagem no tempo possível.
Esse projeto simula o efeito visual do componente, com suas luzes em formato de Y.
Agora é só montar uma caixa para o projeto, instalar no carro e atingir a velocidade de 88 milhas por hora. E não podemos esquecer que o carro precisa também estar com plutônio, para conseguir os 1,21 gigawatts de potência para alimentar o capacitor de fluxo.
"Great Scott"!!
/*-----------------------------
Programa : CAPACITOR DE FLUXO
Autor : Fellipe Couto
Data : 14/02/2016
-----------------------------*/
#define totalLeds 4
int led[totalLeds] = {4, 5, 6, 7}; //Vetor com os pinos dos leds
/*----- SETUP -----*/
void setup() {
//Configura os pinos como saida
for (int i = 0; i < totalLeds; i++) {
pinMode(led[i], OUTPUT);
}
}
/*----- LOOP PRINCIPAL -----*/
void loop() {
digitalWrite(led[0], HIGH);
delay(2000);
flux(150, 10);
flux(60, 70);
flux(40, 90);
flux(20, 70);
flux(10, 60);
digitalWrite(led[3], HIGH);
delay(1000);
digitalWrite(led[3], LOW);
delay(1000);
}
/*----- CAPACITOR DE FLUXO -----*/
void flux(int delayTime, int laps) {
for (int j = 0; j < laps; j++) {
for (int i = 0; i < totalLeds; i++) {
digitalWrite(led[i], HIGH);
delay(delayTime);
digitalWrite(led[i], LOW);
delay(delayTime / 2);
}
delay(delayTime * 2);
}
}
Quando desenvolvemos um projeto com o Arduino nosso de cada dia, muitas vezes precisamos manter os valores de algumas variáveis, de forma que seja possível desligar o circuito sem a perda da mesma.
Um circuito de um relógio, por exemplo, para ter a função alarme/despertador, temos que guardar o horário em memória.
A biblioteca que já conhecemos e utilizamos para acessar a memória, nos permite escrever em cada endereço apenas 1 byte (valores de 0 a 255).
Mas se precisarmos armazenar um valor lido por um sensor conectado na porta analógica, que nos retorna valores de 0 a 1024?
E se entre as infinitas possibilidades, precisarmos armazenar um valor compreendido entre 0 a 999999999?
É, nesse caso já começamos a ter um bom trabalho pela frente. Foi pensando nisso que resolvi montar essa biblioteca que faz esse gerenciamento da memória EEPROM, e facilita a minha vida!
E só incluir a MemoryLib.h no projeto e vida nova!
Agora pode-se armazenar variáveis do tipo int e também do tipo long. Sem dor de cabeça.
A sintaxe para escrever na memória é:
memory.write(endereço, valor)
Para retornar o valor armazenado na memória:
memory.read(endereço)
Para ser mais prático no exemplo, vamos armazenar uma varíavel do tipo int no endereço 5 da EEPROM, e em seguida ler o valor gravado.
int valor = 32767;
memory.write(5, valor);
int valorLido = memory.read(5);
E se a variável fosse do tipo long, como seria? A mesma coisa!
long valor = 2147483647;
memory.write(5, valor);
long valorLido = memory.read(5);
Ficou fácil utilizar a EEPROM agora!
Senhoras e senhores, venho por meio deste compartilhar essa íncrivel biblioteca com vocês.
E o laser não erra! Projeto simples, mas muito interessante!
As posições são gravadas manualmente através de dois potenciômetros. Após isso, o robô mira laser trabalha sozinho. O movimento é feito por dois servo motores.
Já pensou que é essa a base de funcionamento de um robô de solda?! Com criatividade, a partir desse projeto podemos ter vários outros!
Segue o esquema elétrico do circuito e o código fonte.
Valeu! Abraços!
/*-----------------------
Programa : MIRA LASER
Autor : Fellipe Couto
Data : 03/05/2014
-----------------------*/
#include <Servo.h> //Biblioteca do Servo Motor
#define servo1 6 //Servo motor 1 no pino 6
#define servo2 7 //Servo motor 2 no pino 7
#define laser 8 //Laser no pino 8
#define potX A0 //Potenciometro 1 (right / left) ligado na entrada analogica A0
#define potY A1 //Potenciometro 2 (up / down) ligado na entrada analogica A1
#define bRec A2 //Botao para gravar as posicoes ligado na entrada analogica A2, com resistor de pull-down 10K
Servo servoRightLeft; //Varíavel do servo motor para direita e esquerda
Servo servoUpDown; //Varíavel do servo motor para cima e para baixo
int pX[100] = {}; //Array com as posicoes gravadas de right/left
int pY[100] = {}; //Array com as posicoes gravadas de up/down
int qtdRec = 0; //Quantidade de posicoes gravadas
boolean rec = true;
/*----- SETUP -----*/
void setup() {
//Configura o pino do laser
pinMode(laser, OUTPUT);
//Configura os pinos dos servos
servoRightLeft.attach(servo1);
servoUpDown.attach(servo2);
}
/*----- LOOP PRINCIPAL -----*/
void loop() {
if (rec == true) {
target();
} else {
autoLaser();
}
}
/*----- LASER MANUAL PARA GRAVAR OS ALVOS -----*/
void target() {
//Laser ligado
digitalWrite(laser, HIGH);
//Posicoes do potenciometro
int x = map(analogRead(potX), 0, 1023, 0, 180);
int y = map(analogRead(potY), 0, 1023, 0, 180);
//Posiciona os servos
servoRightLeft.write(x);
servoUpDown.write(y);
//Se o botao for pressionado, grava as posicoes
if (analogRead(bRec) == 1023) {
qtdRec++;
pX[qtdRec] = x;
pY[qtdRec] = y;
blinkLaser();
//Se o botao permanecer pressionado apos o laser piscar, inicia a mira automatica
if (analogRead(bRec) == 1023) {
rec = false;
delay(2000);
}
}
}
/*----- LASER AUTOMATICO -----*/
void autoLaser() {
for (int i = 1; i <= qtdRec; i++) {
//Posiciona os servos
servoRightLeft.write(pX[i]);
servoUpDown.write(pY[i]);
delay(500);
//Pisca o laser
blinkLaser();
//Se o botao permanecer pressionado apos o laser piscar, finaliza a mira automatica
if (analogRead(bRec) == 1023) {
rec = true;
i = qtdRec + 1;
delay(2000);
//Se o botao permanecer pressionado após o delay, não mantem as posicoes que ja estavam gravadas
if (analogRead(bRec) == 1023) {
qtdRec = 0;
digitalWrite(laser, HIGH);
delay(1000);
digitalWrite(laser, LOW);
delay(2000);
}
}
}
}
/*----- PISCA O LASER -----*/
void blinkLaser() {
for (int i = 0; i < 15; i++) {
digitalWrite(laser, HIGH);
delay(50);
digitalWrite(laser, LOW);
delay(50);
}
}
Quem não lembra desse clássico jogo da memória? O jogador precisa repetir a sequência exibida, e a cada acerto vai ficando mais difícil. Um bom passatempo e um ótimo exercício pra cabeça!
O jogo memoriza a pontuação máxima. Assim você pode verificar qual foi o seu recorde. Para isso, basta ligar o jogo com o botão do led verde pressionado. Isso fará com que o led pisque o número de vezes da pontuação recorde. Se quiser resetar a memória, mantenha o botão pressionado até o led parar de piscar. E quando um recorde de pontuação for batido, ao final do jogo o led verde piscará.
Então o objetivo é ver o led verde piscar! É recorde de pontuação batido!
Fiz o circuito utilizando a plataforma Arduino, e montei numa placa de fenolite de 8x7 cm.
Segue o esquema elétrico do circuito e o código fonte do microcontrolador.
Abraços!
/*-----------------------------
Programa : GENIUS (SIMON GAME)
Autor : Fellipe Couto
Data : 04/04/2014
-----------------------------*/
#include <EEPROM.h> //Biblioteca da memória EEPROM
long previousMillis = 0;
long interval = 1000; //Tempo do intervalo dentro do loop. 1000 milisegundos (1 segundo)
int timeControl = 0; //Controla o tempo de ociosidade
int led[4] = {12, 11, 10, 9}; //Pinos dos Leds
int but[4] = {5, 6, 7, 8}; //Pinos dos botões
int sequence[100]; //Array com a sequencia do jogo
int countGame = 0;
int countInput = 0;
int maxScore = EEPROM.read(0); //Retorna o valor do score armazenado na EEPROM
boolean play = true;
/*----- SETUP -----*/
void setup() {
for (int i = 0; i < 4; i++) {
pinMode(led[i], OUTPUT); //Configura os pinos como saída
pinMode(but[i], INPUT); //Configura os pinos como entrada
}
randomSeed(analogRead(0)); //Para o random não repetir a sequencia
score(); //Função para verificar e exibir a pontuação
start(); //Inicia o jogo
}
/*----- LOOP PRINCIPAL -----*/
void loop() {
unsigned long currentMillis = millis();
//Intervalo de 1 segundo
if (currentMillis - previousMillis > interval) {
previousMillis = currentMillis;
timeControl++; //Incrementa a variável de controle de tempo
if (timeControl >= 10) { //Ficando 10 segundos sem pressionar, inicia o jogo novamente
start();
}
}
if (play == true) {
game();
}
else {
player();
}
}
/*----- SORTEIO DO JOGO -----*/
void game() {
countGame++;
sequence[countGame] = random(4); //de 0 a 3
for (int i = 1; i <= countGame; i++) {
digitalWrite(led[sequence[i]], HIGH);
delay(400);
digitalWrite(led[sequence[i]], LOW);
delay(150);
}
play = false;
}
/*----- JOGADOR -----*/
void player() {
int input = 4;
int t = 300;
//Leitura dos botões
for (int b = 0; b < 4; b++) {
if (digitalRead(but[b]) == 1) {
digitalWrite(led[b], HIGH);
delay(t);
input = b;
}
}
//Apaga todos os leds
for (int i = 0; i < 4; i++) {
digitalWrite(led[i], LOW);
}
if (input != 4) { //Se algum botão foi pressionado
timeControl = 0;
countInput++;
if (sequence[countInput] != input) { //Errou a sequencia
delay(t);
blinkLeds(8, 150); //Pisca os leds indicando o erro
score(); //Verifica a pontuação
delay(3000);
start(); //Inicia o jogo novamente
}
else if (countInput == countGame) { //Acertou a sequencia
countInput = 0;
play = true;
delay(t);
blinkLeds(1, 1000);
}
}
}
/*----- SEQUENCIA INICIAL DE PISCAR DOS LEDS -----*/
void start() {
countGame = 0;
countInput = 0;
timeControl = 0;
play = true;
//Pisca os leds randomicamente
for (int i = 0; i < 15; i++) {
int x = random(4);
digitalWrite(led[x], HIGH);
delay(20);
digitalWrite(led[x], LOW);
delay(100);
}
//Apaga e acende os leds em sequencia
for (int y = 0; y < 3; y++) {
for (int i = 0; i < 4; i++) {
digitalWrite(led[i], LOW);
delay(80);
}
for (int i = 0; i < 4; i++) {
digitalWrite(led[i], HIGH);
delay(80);
}
}
delay(1000);
//Apaga todos os leds
for (int i = 0; i < 4; i++) {
digitalWrite(led[i], LOW);
}
delay(1000);
}
/*----- PISCA OS LEDS -----*/
void blinkLeds(int qtd, int t) {
//qtd = quantidade de piscadas / t = tempo
for (int y = 0; y < qtd; y++) {
//Acende todos os leds
for (int i = 0; i < 4; i++) {
digitalWrite(led[i], HIGH);
}
delay(t);
//Apaga todos os leds
for (int i = 0; i < 4; i++) {
digitalWrite(led[i], LOW);
}
delay(t);
}
}
/*----- VERIFICA, EXIBE E GRAVA A PONTUAÇÃO -----*/
void score() {
//Zera a EEPROM caso esteja acima de 100.
if (maxScore > 100) {
EEPROM.write(0, 0);
maxScore = 0;
}
//Verifica a pontuação
if (countGame - 1 > maxScore) {
EEPROM.write(0, countGame - 1);
maxScore = countGame - 1;
for (int i = 0; i < 100; i++) {
digitalWrite(led[0], HIGH);
delay(50);
digitalWrite(led[0], LOW);
delay(50);
}
}
else if (digitalRead(but[0]) == 1) {
//Se o verde estiver pressionado, exibe a pontuação piscando o led verde
for (int i = 0; i < maxScore; i++) {
digitalWrite(led[0], HIGH);
delay(500);
digitalWrite(led[0], LOW);
delay(500);
}
delay(1000);
if (digitalRead(but[0]) == 1) {
//Após exibir a pontuação, efetua o reset dos pontos caso o botão verde estiver pressionado
EEPROM.write(0, 0);
maxScore = 0;
}
}
}
Hoje em dia é comum nos estacionamentos essa facilidade para encontrarmos as vagas disponíveis. Em cima de cada vaga existe um sensor, e se a vaga estiver disponível temos uma luz verde acesa, caso contrário, uma luz vermelha.
Fiz um exemplo utilizando um sensor ultrassônico HC-SR04. Quando o sensor é ativado, ele calcula a distância até o chão, mantendo esse valor como base. Quando um valor menor for detectado, a luz verde é acionada.
Reparem que o carro não é detectado de forma instantânea, e isso é devido a um delay colocado de forma proposital para o led verde não ser acionado com qualquer objeto de passagem pelo sensor.
É isso aí!
/*-------------------------
Programa : SENSOR DE VAGAS
Autor : Fellipe Couto
Data : 10/04/2014
-------------------------*/
//Inclui a biblioteca do sensor
#include <Ultrasonic.h>
//Define os pinos usados
#define trig 12
#define echo 13
#define ledRed 10
#define ledGreen 11
int dist1 = 0; //Variável com a distância inicial, do sensor até o piso
int dist2 = 0; //Variável com as novas distâncias medidas pelo sensor
//Inicia a biblioteca do sensor, passando os parametros de uso
Ultrasonic ultrasonic(trig, echo);
void setup() {
pinMode(trig, OUTPUT); //Configura o pino do trig como saida (envia o pulso)
pinMode(echo, INPUT); //Configura o pino do echo como entrada (recebe o pulso)
pinMode(ledRed, OUTPUT); //Configura o pino do led vermelho como saída
pinMode(ledGreen, OUTPUT); //Configura o pino do led vermelho como saída
dist1 = ultrasonic.Ranging(CM) * 0.9; //Efetua a calibragem da distância. 90% da medida final para não detectar um objeto pequeno qualquer
}
void loop() {
delay(6000);
dist2 = ultrasonic.Ranging(CM);
if (dist1 > dist2) {
digitalWrite(ledRed, HIGH);
digitalWrite(ledGreen, LOW);
} else {
digitalWrite(ledRed, LOW);
digitalWrite(ledGreen, HIGH);
}
}
A base desse circuito é a mesma de um carro seguidor de linha, por exemplo. São dois sensores de luminosidade, um do lado direito e outro do lado esquerdo, e assim detecta a variação da intensidade da luz. Quando o sensor da esquerda marca um valor mais alto que o da direita, o motor gira para a esquerda, e o mesmo acontece para o lado direito.
Segue o esquema elétrico e o código fonte.
Valeu!
/*-------------------------
Programa : SEGUIDOR DE LUZ
Autor : Fellipe Couto
Data : 08/04/2014
-------------------------*/
#include <Servo.h> //Biblioteca do Servo Motor
#define servo 6 //Servo motor no pino 6
Servo myservo; //Varíavel do servo motor
int pos = 90; //Posicao do servo
int ldr1 = 0; //Valor do LDR 1
int ldr2 = 0; //Valor do LDR 2
void setup() {
myservo.attach(servo); //Configura o pino do Servo Motor
myservo.write(pos); //Servo na posicao inicial
}
void loop() {
delay(50);
ldr1 = analogRead(0);
ldr2 = analogRead(1);
if (ldr1 > ldr2 && pos > 0) {
myservo.write(pos--);
} else if (ldr1 < ldr2 && pos < 180) {
myservo.write(pos++);
}
}
Bom dia!!!! Alô alô!!
Um projeto fácil e simples. Pressionou o botão e acontece o sorteio dos números.
Agora podemos dar uma incrementada e incluir mais Leds formando outros dados. Jogar WAR com os dados eletrônicos fica maneiro! Hehehe...
Ta aí o esquema elétrico e o código fonte para o arduino.
Valeu! Abraços!
/*----------------------------
D A D O E L E T R O N I C O
FELLIPE COUTO - 11/02/2013
---------------------------*/
int led[7] = {2, 3, 4, 5, 6, 7, 8}; //Pinos dos LEDs
int dado[7][7] = {
{0, 0, 0, 0, 0, 0, 0}, //ZERO
{0, 0, 0, 0, 0, 0, 1}, //UM
{0, 0, 1, 0, 0, 1, 0}, //DOIS
{0, 0, 1, 0, 0, 1, 1}, //TRES
{1, 0, 1, 1, 0, 1, 0}, //QUATRO
{1, 0, 1, 1, 0, 1, 1}, //CINCO
{1, 1, 1, 1, 1, 1, 0} //SEIS
};
void setup(){
for (int i=0; i<7; i++){ //Configura os pinos dos LEDs como saída.
pinMode(led[i], OUTPUT);
}
randomSeed(analogRead(0)); //Para o random não repetir a sequencia.
}
void loop(){
if (analogRead(1) == 1023){
sorteio();
}
}
void sorteio(){
int t = 30;
for (int x=0; x<20; x++){
int n = random(6) + 1; //Numero aleatorio para ser exibido. De 1 a 6.
t = t + 10; //Incrementa o valor de t para ir aumentando o delay.
for (int i=0; i<7; i++){ //Todos apagados.
digitalWrite(led[i], dado[0][i]);
}
delay(t);
for (int i=0; i<7; i++){ //Exibe o numero aleatorio da variável n.
digitalWrite(led[i], dado[n][i]);
}
delay(t);
}
}
Fala ae! Fala ae!
Sabe quando você precisa de mais que um pisca-alerta no trânsito?
Eu imagino que circular com isso ligado não seja permitido por lei, mas uma vez ou outra, usando com responsabilidade... Só não falar pra polícia que aprenderam aqui no blog, ta bom!
Usei um par dessas lanternas de Leds que encontramos em qualquer loja de peças pra automóveis, e até em camelô já vi vendendo. Esse modelo são 8 Leds em cada.
O circuito fiz baseado na plataforma Arduino e foi montado numa placa de fenolite de 7x4cm.
Como podem ver no código do microcontrolador, existe uma chave que liga sinal alto ao pino 9. Dessa forma podemos deixar a lanterna sempre ligada, sem o pisca.
Agora é só instalar no carro!
Segue o esquema elétrico do circuito, fotos da pci, e o código fonte
/*-----------------
S A F E T Y C A R
Fellipe Couto
16/09/2012
-----------------*/
#define L1 2
#define L2 3
#define strobe 9
void setup(){
pinMode(L1,OUTPUT);
pinMode(L2,OUTPUT);
pinMode(strobe, INPUT);
}
void loop(){
if (digitalRead(strobe) == HIGH){
strobe1(15);
strobe2(12);
strobe3(7);
strobe4(7);
}
else{
digitalWrite(L1, HIGH);
digitalWrite(L2, HIGH);
}
}
void strobe1(int qtd){
int t = 50;
for (int q=0; q<qtd; q++){
for (int i=0; i<3; i++){
digitalWrite(L1,HIGH);
delay(t);
digitalWrite(L1,LOW);
delay(t);
}
for (int i=0; i<3; i++){
digitalWrite(L2,HIGH);
delay(t);
digitalWrite(L2,LOW);
delay(t);
}
}
}
void strobe2(int qtd){
int x = 5;
int t = 40;
for (int q=0; q<qtd; q++){
for (int i=0; i<x; i++){
digitalWrite(L1,HIGH);
digitalWrite(L2,HIGH);
delay(t);
digitalWrite(L1,LOW);
digitalWrite(L2,LOW);
delay(t);
}
delay(200);
}
}
void strobe3(int qtd){
int t = 400;
int t1 = 60;
for (int i=0; i<qtd; i++){
digitalWrite(L1,HIGH);
digitalWrite(L2,HIGH);
delay(20);
digitalWrite(L1,LOW);
digitalWrite(L2,LOW);
delay(t);
digitalWrite(L1,HIGH);
delay(t1);
digitalWrite(L1,LOW);
digitalWrite(L2,HIGH);
delay(t1);
digitalWrite(L2,LOW);
digitalWrite(L1,HIGH);
delay(t1);
digitalWrite(L1,LOW);
digitalWrite(L2,HIGH);
delay(t1);
digitalWrite(L1,LOW);
digitalWrite(L2,LOW);
delay(t);
}
}
void strobe4(int qtd){
int t = 20;
int t1 = 500;
for (int i=0; i<qtd; i++){
digitalWrite(L1,HIGH);
digitalWrite(L2,HIGH);
delay(t);
digitalWrite(L1,LOW);
digitalWrite(L2,LOW);
delay(t1);
}
}
Para acionar lâmpadas, motores, e qualquer outro tipo de carga que não seja de baixa corrente uma das opções é a utilização de relés.
Um relé nada mais é que um interruptor acionado elétricamente.
Se quiser entender melhor seu funcionamento: Relé - Wikipédia
Esse é um módulo relé duplo, que custou em torno de 5 pratas pra fazer.
Lista de materiais:
Relé 5v - 02 unidades
Diodo 1N4007 - 02 unidades
Resistor 1KΩ - 02 unidades
Resistor 220Ω - 03 unidades
LED Verde 3mm - 02 unidades
LED amarelo 3mm - 01 unidade
Transistor BC548 - 02 unidades
Borne de conexão - 02 unidades
Barra de pinos fêmea - 01 unidade
Placa de fenolite - 01 unidade
Para acionar os relés, utilizamos um pequeno circuito com transistores. Assim uma pequena corrente aplicada a base dos transistores já é capaz de efetuar o acionamento dos relés. Dessa forma podemos usar um circuito de baixa corrente, como sensores e/ou um Arduino para aciona-los.
O esquema elétrico base de um circuito de relés:
O módulo possui um Led amarelo que indica que o circuito está energizado e dois Leds verdes para indicar o acionamento dos relés. Foi montado numa placa de fenolite de 4x6 cm.
Depois de pronto, ficou assim:
A barra de pinos para conexão do módulo está na seguinte ordem: Vcc, Gnd, Relé1, Relé2.
Fácil, simples, barato! Funcionando que é uma belezura!
Um sequencial de 18 canais com 12 Leds RGB! Agora a discoteca ficou pronta! :P
Fiz o circuito baseado na plataforma Arduino. Com os 18 canais consigo controlar 6 Leds RGB individualmente, e dessa forma liguei os outros 6 Leds em paralelo.
A montagem final fiz em duas placas, sendo uma para os Leds e outra para o circuito do microcontrolador.
Não programei muitas sequencias, mas o efeito já ficou bem bacana!
Segue o esquema elétrico e o código fonte.
Abraços!
/*-------------
DISCO RGB
Fellipe Couto
06/10/2012
-------------*/
int total = 6;
int r[6] = {
0,3,6,9,12,15};
int g[6] = {
1,4,7,10,13,16};
int b[6] = {
2,5,8,11,14,17};
/*----- SETUP -----*/
void setup(){
for (int i=0; i<total; i++){
pinMode(r[i], OUTPUT);
pinMode(g[i], OUTPUT);
pinMode(b[i], OUTPUT);
}
randomSeed(analogRead(5)); //Para o random ficar aleatorio, sem repetir a sequencia.
startRGB();
}
/*----- LOOP PRINCIPAL -----*/
void loop(){
int disco = random(9);
switch (disco){
case 0:
blinkRGB(40);
flashRGB(6);
blinkRGB(7);
flashRGBdouble(2);
break;
case 1:
discoSwapColor(6, 80);
discoSwapColor(7, 50);
discoSwapColor(10, 30);
break;
case 2:
discoRGB(7, 100);
discoRGB(6, 200);
discoRGB(11, 70);
break;
case 3:
discoSwapColor(4, 100);
discoSwapColor(3, 50);
break;
case 4:
flashRGBall(6);
break;
case 5:
flashRGBdouble(5);
break;
case 6:
police();
break;
case 7:
runDiscoRGBrandom(7);
break;
case 8:
running(12);
break;
}
}
/*----- APAGA TODOS OS LEDS -----*/
void turnOff(){
for (int i=0; i<total; i++){
digitalWrite(r[i], LOW);
digitalWrite(g[i], LOW);
digitalWrite(b[i], LOW);
}
}
/*----- TODOS ACESSOS -----*/
void turnOn(){
for (int i=0; i<total; i++){
digitalWrite(r[i], HIGH);
digitalWrite(g[i], HIGH);
digitalWrite(b[i], HIGH);
}
}
/*----- VERMELHO -----*/
void red(){
turnOff();
for (int i=0; i<total; i++){
digitalWrite(r[i], HIGH);
}
}
/*----- VERDE -----*/
void green(){
turnOff();
for (int i=0; i<total; i++){
digitalWrite(g[i], HIGH);
}
}
/*----- AZUL -----*/
void blue(){
turnOff();
for (int i=0; i<total; i++){
digitalWrite(b[i], HIGH);
}
}
/*----- START -----*/
void startRGB(){
turnOff();
delay(1000);
turnOn();
delay(3000);
for (int k=0; k<50; k++){
turnOff();
delay(20);
turnOn();
delay(20);
}
turnOff();
delay(1000);
}
/*----- CORRIDA VERMELHO -----*/
void runRed(int qtd, int s, boolean clockwise){
//qtd = Quantidade de voltas.
//s = Velocidade.
//clockwise = Sentido da volta.
for (int x=0; x<qtd; x++){
turnOff();
if (clockwise == true){
for (int i=0; i<total; i++){
digitalWrite(r[i], HIGH);
delay(s);
digitalWrite(r[i], LOW);
}
}
else{
for (int i=total-1; i>=0; i--){
digitalWrite(r[i], HIGH);
delay(s);
digitalWrite(r[i], LOW);
}
}
}
}
/*----- CORRIDA VERDE -----*/
void runGreen(int qtd, int s, boolean clockwise){
//qtd = Quantidade de voltas.
//s = Velocidade.
//clockwise = Sentido da volta.
for (int x=0; x<qtd; x++){
turnOff();
if (clockwise == true){
for (int i=0; i<total; i++){
digitalWrite(g[i], HIGH);
delay(s);
digitalWrite(g[i], LOW);
}
}
else{
for (int i=total-1; i>=0; i--){
digitalWrite(g[i], HIGH);
delay(s);
digitalWrite(g[i], LOW);
}
}
}
}
/*----- CORRIDA AZUL -----*/
void runBlue(int qtd, int s, boolean clockwise){
//qtd = Quantidade de voltas.
//s = Velocidade.
//clockwise = Sentido da volta.
for (int x=0; x<qtd; x++){
turnOff();
if (clockwise == true){
for (int i=0; i<total; i++){
digitalWrite(b[i], HIGH);
delay(s);
digitalWrite(b[i], LOW);
}
}
else{
for (int i=total-1; i>=0; i--){
digitalWrite(b[i], HIGH);
delay(s);
digitalWrite(b[i], LOW);
}
}
}
}
/*----- SEQUENCIAL CORRIDA RANDOM -----*/
void runDiscoRGBrandom(int qtd){
for (int z=0; z<qtd; z++){
int qtdRun = random(1,6);
int s = random(30, 70);
int rgb = random(3);
boolean clockwise = random(2);
switch (rgb){
case 0:
runRed(qtdRun, s, clockwise);
break;
case 1:
runGreen(qtdRun, s, clockwise);
break;
case 2:
runBlue(qtdRun, s, clockwise);
break;
}
}
}
/*----- CORRIDA COM COR DE FUNDO -----*/
void run(int qtd, int s, boolean clockwise, int color, int bgcolor){
//qtd = Quantidade de voltas.
//s = Velocidade.
//clockwise = Sentido da volta.
//color = Cor da volta. (0 = RED / 1 = GREEN / 2 = BLUE);
//bgcolor = Cor de fundo.
if (clockwise == true){
for (int j=0; j<qtd; j++){
for (int i=0; i<6; i++){
//BACKGROUND COLOR
if (bgcolor == 0){
red();
digitalWrite(r[i], LOW);
}
else if (bgcolor == 1){
green();
digitalWrite(g[i], LOW);
}
else if (bgcolor == 2){
blue();
digitalWrite(b[i], LOW);
}
//COLOR
if (color == 0){
digitalWrite(r[i], HIGH);
}
else if (color == 1){
digitalWrite(g[i], HIGH);
}
else if (color == 2){
digitalWrite(b[i], HIGH);
}
delay(s);
}
}
}
else{
for (int j=0; j<qtd; j++){
for (int i=5; i>=0; i--){
//BACKGROUND COLOR
if (bgcolor == 0){
red();
digitalWrite(r[i], LOW);
}
else if (bgcolor == 1){
green();
digitalWrite(g[i], LOW);
}
else if (bgcolor == 2){
blue();
digitalWrite(b[i], LOW);
}
//COLOR
if (color == 0){
digitalWrite(r[i], HIGH);
}
else if (color == 1){
digitalWrite(g[i], HIGH);
}
else if (color == 2){
digitalWrite(b[i], HIGH);
}
delay(s);
}
}
}
}
/*----- CORRIDA COM CORES RANDOMICAS -----*/
void running(int qtd){
for (int i=0; i<qtd; i++){
int qtdRun = random(1,8);
int s = random(30, 80);
int rgbColor = random(3);
int rgbBgColor = random(3);
boolean clockwise = random(2);
while (rgbColor == rgbBgColor){
rgbBgColor = random(3);
}
run(qtdRun, s, clockwise, rgbColor, rgbBgColor);
}
}
/*----- PISCA CORES -----*/
void blinkRGB(int qtd){
for (int i=0; i<qtd; i++){
int rgb = random(4);
int s = random(30, 150);
switch (rgb){
case 0:
red();
break;
case 1:
green();
break;
case 2:
blue();
break;
case 3:
turnOn();
break;
}
delay(s);
}
}
/*----- FLASHS RANDOMICOS -----*/
void flashRGB(int qtd){
int t1 = 15;
int t2 = 100;
int rgb = random(3);
int led = random(total);
turnOff();
for (int i=0; i<qtd*10; i++){
int rgb = random(3);
int led = random(total);
switch (rgb){
case 0:
digitalWrite(r[led],HIGH);
delay(t1);
digitalWrite(r[led],LOW);
delay(t2);
break;
case 1:
digitalWrite(g[led],HIGH);
delay(t1);
digitalWrite(g[led],LOW);
delay(t2);
break;
case 2:
digitalWrite(b[led],HIGH);
delay(t1);
digitalWrite(b[led],LOW);
delay(t2);
break;
}
}
}
/*----- FLASHS RANDOMICOS DUPLO -----*/
void flashRGBdouble(int qtd){
int t1 = 15;
int t2 = 100;
int rgb = random(3);
int led = random(total);
turnOff();
for (int i=0; i<qtd*10; i++){
int rgb = random(3);
int led = random(total);
switch (rgb){
case 0:
digitalWrite(r[led],HIGH);
digitalWrite(r[led+1],HIGH);
delay(t1);
digitalWrite(r[led],LOW);
digitalWrite(r[led+1],LOW);
delay(t2);
break;
case 1:
digitalWrite(g[led],HIGH);
digitalWrite(g[led+1],HIGH);
delay(t1);
digitalWrite(g[led],LOW);
digitalWrite(g[led+1],LOW);
delay(t2);
break;
case 2:
digitalWrite(b[led],HIGH);
digitalWrite(b[led+1],HIGH);
delay(t1);
digitalWrite(b[led],LOW);
digitalWrite(b[led+1],LOW);
delay(t2);
break;
}
}
}
/*----- FLASHS TODOS LEDS-----*/
void flashRGBall(int qtd){
int t1 = 40;
int t2 = 100;
for (int w=0; w<qtd; w++){
int rgb = random(3);
for (int i=0; i<7; i++){
if (rgb == 0){
red();
}
else if (rgb == 1){
green();
}
else{
blue();
}
delay(t1);
turnOff();
delay(t1);
}
delay(t2);
}
}
/*----- TROCA DE CORES -----*/
void discoSwapColor(int qtd, int s){
int t = s*3;
for (int z=0; z<qtd; z++){
int clockwise = random(2);
int rgb = random(3);
switch (rgb){
case 0:
//Acende Vermelho
if (clockwise == 0){
for (int i=0; i<total; i++){
digitalWrite(r[i], HIGH);
digitalWrite(g[i], LOW);
digitalWrite(b[i], LOW);
delay(s);
}
}
else{
for (int i=total-1; i>=0; i--){
digitalWrite(r[i], HIGH);
digitalWrite(g[i], LOW);
digitalWrite(b[i], LOW);
delay(s);
}
}
delay(t);
break;
case 1:
//Acende Verde
if (clockwise == 0){
for (int i=0; i<total; i++){
digitalWrite(r[i], LOW);
digitalWrite(g[i], HIGH);
digitalWrite(b[i], LOW);
delay(s);
}
}
else{
for (int i=total-1; i>=0; i--){
digitalWrite(r[i], LOW);
digitalWrite(g[i], HIGH);
digitalWrite(b[i], LOW);
delay(s);
}
}
delay(t);
break;
case 2:
//Acende Azul
if (clockwise == 0){
for (int i=0; i<total; i++){
digitalWrite(r[i], LOW);
digitalWrite(g[i], LOW);
digitalWrite(b[i], HIGH);
delay(s);
}
}
else{
for (int i=total-1; i>=0; i--){
digitalWrite(r[i], LOW);
digitalWrite(g[i], LOW);
digitalWrite(b[i], HIGH);
delay(s);
}
}
delay(t);
break;
}
}
}
/*----- RODA COM UM LED EM CADA COR -----*/
void discoRGB(int qtd, int s){
int clockwise = random(2);
turnOff();
for (int x=0; x<qtd; x++){
if (clockwise == 0){
for (int i=0; i<4; i++){
digitalWrite(r[i], HIGH);
digitalWrite(g[i+1], HIGH);
digitalWrite(b[i+2], HIGH);
delay(s);
digitalWrite(r[i], LOW);
digitalWrite(g[i+1], LOW);
digitalWrite(b[i+2], LOW);
}
}
else{
for (int i=3; i>=0; i--){
digitalWrite(r[i], HIGH);
digitalWrite(g[i+1], HIGH);
digitalWrite(b[i+2], HIGH);
delay(s);
digitalWrite(r[i], LOW);
digitalWrite(g[i+1], LOW);
digitalWrite(b[i+2], LOW);
}
}
}
}
/*----- EFEITO POLICIA -----*/
void police(){
int t = 30;
//Metade vermelho e metade azul.
for (int i=0; i<3; i++){
for (int k=0; k<15; k++){
digitalWrite(r[0], HIGH);
digitalWrite(r[1], HIGH);
digitalWrite(r[2], HIGH);
delay(t);
turnOff();
delay(t);
}
for (int k=0; k<15; k++){
digitalWrite(b[3], HIGH);
digitalWrite(b[4], HIGH);
digitalWrite(b[5], HIGH);
delay(t);
turnOff();
delay(t);
}
}
delay(100);
//Todos juntos.
for (int i=0; i<3; i++){
for (int k=0; k<15; k++){
red();
delay(t);
turnOff();
delay(t);
}
for (int k=0; k<15; k++){
blue();
delay(t);
turnOff();
delay(t);
}
}
}
Sabe aqueles alarmes com lasers voando pra todo lado? O laser vai refletindo em espelhos até chegar em um sensor, que quando detecta um corte na luz , aciona a sirene, as luzes, e tudo mais!
Segue o esquema elétrico do circuito e o código fonte do microcontrolador.
/*-------------
SENSOR LASER
Fellipe Couto
26/09/2012
-------------*/
#define ledVermelho 2
#define ledAzul 3
int valorMaxLDR = 1000; //Valor com laser projetado.
void setup(){
pinMode(ledVermelho, OUTPUT);
pinMode(ledAzul, OUTPUT);
}
void loop(){
int LDR = analogRead(0);
if (LDR < valorMaxLDR - 50){
Alarme();
}
}
void Alarme(){
int t = 400;
for (int i=0; i<5; i++){
digitalWrite(ledVermelho, HIGH);
digitalWrite(ledAzul, LOW);
delay(t);
digitalWrite(ledVermelho, LOW);
digitalWrite(ledAzul, HIGH);
delay(t);
}
digitalWrite(ledVermelho, LOW);
digitalWrite(ledAzul, LOW);
}
O projeto é composto basicamente de um display de 7 segmentos com 4 digitos e anodo comum, um CI 74HC595, um Led IR, um receptor IR (fototransitor) e um arduino.
Para o funcionamento correto desse display é necessário multiplexar os digitos. Reparem no código que apenas um digito é acionado por vez.
Segue o esquema elétrico do display, o esquema do projeto, e o código fonte.
Valeu!
/*-------------------------------------
CONTADOR DE PASSAGEM
4 digitos / 7 segmentos / anodo comum.
Fellipe Couto - 22/09/2012
------------------------------------*/
/*
LIGACAO DOS PINOS DO DISPLAY AO REGISTRADOR:
74HC595 - 15 | 01 | 02 | 03 | 04 | 05 | 06 | 07 |
DISPLAY - 14 | 16 | 13 | 03 | 05 | 11 | 15 | |
Ex.: Pino 15 do registrador ligado ao pino 14 do display, com resistor 220 ohms;
ARDUINO - 02 | 03 | 04 | 05
DISPLAY - 01 | 02 | 06 | 08
Ex.: Pino 2 do arduino ligado ao pino 1 do display, com resistor 220 ohms;
LIGACAO DO 'DOIS PONTOS' DO DISPLAY:
-Pino 6 do Arduino é ligado ao pino 4 do display, com um resistor de 220 ohms.
-Pino 12 do display é ligado ao GND.
*/
int latchPin = 8; //Conectado ao pino 12 do 74HC595.
int clockPin = 12; //Conectado ao pino 11 do 74HC595.
int dataPin = 11; //Conectado ao pino 14 do 74HC595.
int d[5] = {
2, 3, 4, 5, 6}; //digito 1, digito, 2, digito 3, digito 4, dois-pontos.
int count = 0;
long previousMillis = 0;
long interval = 1000;
void setup(){
pinMode(latchPin,OUTPUT);
pinMode(clockPin,OUTPUT);
pinMode(dataPin,OUTPUT);
for (int i=0; i<5; i++){
pinMode(d[i], OUTPUT);
}
}
void loop(){
if (analogRead(0) > 90){
if(millis() - previousMillis > interval) {
previousMillis = millis();
count++;
}
}
displayNumber(count);
}
void displayNumber(int num){
int n[4];
String aux;
if (num > 9999){
num = 0;
}
if (num < 10){
aux += "000";
aux += num;
}
else if (num < 100){
aux += "00";
aux += num;
}
else if (num < 1000){
aux += "0";
aux += num;
}
else{
aux += num;
}
n[0] = aux.substring(0,1).toInt();
n[1] = aux.substring(1,2).toInt();
n[2] = aux.substring(2,3).toInt();
n[3] = aux.substring(3,4).toInt();
for (int p=0; p<4; p++){ //Acende um digito por vez.
byte bDisplay[10] = {
B11111100, B01100000, B11011010, B11110010, B01100110, B10110110, B10111110, B11100000, B11111110, B11110110 };
for (int i=0; i<4; i++){ //Apaga todos os digitos
digitalWrite(d[i], LOW);
}
digitalWrite(latchPin, LOW); //Define latchPin como LOW, para permitir o envio de dados ao registrador.
shiftOut(~bDisplay[n[p]]); //Envia os dados ao registrador.
digitalWrite(latchPin, HIGH); //Define latchPin como HIGH, para interromper o envio da dados ao registrador.
digitalWrite(d[p], HIGH); //Acende a posição do digito.
delay(1);
}
}
void shiftOut(byte dataOut){
//Desloca 8 bits, com o bit menos significativo (LSB) sendo deslocado primeiro, no extremo ascendente do clock.
boolean pinState;
digitalWrite(dataPin, LOW); //Deixa o registrador de deslocamento pronto para enviar dados.
digitalWrite(clockPin, LOW);
for (int i=0; i<8; i++){ //Para cada bit em dataOut, envie um bit.
digitalWrite(clockPin, LOW); //Define clockPin como LOW antes de enviar o bit.
//Se o valor de dataOut E(&) de uma mascara de bits forem verdadeiros, defina pinState como 1 (HIGH).
if (dataOut & (1<<i)){
pinState = HIGH;
}
else{
pinState = LOW;
}
digitalWrite(dataPin, pinState); //Define dataPin como HIGH ou LOW, dependendo de pinState.
digitalWrite(clockPin, HIGH); //Envia o bit no extremo ascendente do clock.
}
digitalWrite(clockPin, LOW); //Interrompe o deslocamento de dados.
}
Usei praticamente o mesmo código fonte do post Sequencial de LEDs, porém nesse esta incluído a milagrosa biblioteca ShiftWriteMega, que possibilita ampliar o número de saídas do Arduino usando os registradores de deslocamento 74HC595.
A alteração mais significativa no código foi alterar o controle de acionamento dos Leds, onde foi substituído o digitalWrite() pela função mega.shiftWrite() da biblioteca.
O circuito é composto por um Arduino, onde usamos somente 3 saídas, 4 registradores 74HC595, e mais 30 Leds com seus respectivos resistores de 220 ohms.
Segue uma foto dos registradores, a imagem do esquema elétrico, e o código fonte.
That's all folks!
/*-------------------------
SUPER SEQUENCIAL DE LEDS
Fellipe Couto - 19/09/2012
-------------------------*/
//Inclui a bilioteca ShiftOutMega http://www.4shared.com/rar/QSUfwzo4/ShifOutMega.html
#include <ShiftOutMega.h>
//Variáveis de uso dos registradores 74HC595
int latchPin = 8; //Pino 8 conectado ao pino 12 do 74HC595 (Latch).
int dataPin = 11; //Pino 11 conectado ao pino 14 do 74HC595 (Data).
int clockPin = 12; //Pino 12 conectado ao pino 11 do 74HC595 (Clock).
//Quantidade de registradores (74HC595). Para cada registrador, temos 8 saídas.
int qtdRegistradores = 4;
int totalSaidas = 30; //Até 32 saídas com 4 registradores.
int totalSequencias = 10;
int led[] = {
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30}; //Pinos dos leds.
//Inicia a biblioteca passando os parametros de uso.
ShiftOutMega mega(latchPin, dataPin, clockPin, qtdRegistradores);
void setup(){
}
void loop(){
for (int i=1; i<=totalSequencias; i++){
for (int j=0; j<3; j++){
sequencia(i);
}
}
}
//------------------------------
void sequencia(int s){
switch (s){
case 1:
s1();
break;
case 2:
s2();
break;
case 3:
s3();
break;
case 4:
s4();
break;
case 5:
s5();
break;
case 6:
s6();
break;
case 7:
s7();
break;
case 8:
s8();
break;
case 9:
s9();
break;
case 10:
s10();
break;
}
}
//------------------------------
void AcendeTodos(){
for (int i=0; i<totalSaidas; i++){
mega.shiftWrite(led[i],HIGH);
}
}
//------------------------------
void ApagaTodos(){
for (int i=0; i<totalSaidas; i++){
mega.shiftWrite(led[i],LOW);
}
}
//------------------------------
void s1(){
int t1 = 10;
ApagaTodos();
//Acende um por um.
for (int i=0; i<totalSaidas; i++){
mega.shiftWrite(led[i],HIGH);
delay(t1);
}
//Apaga um por um.
for (int i=0; i<totalSaidas; i++){
mega.shiftWrite(led[i],LOW);
delay(t1);
}
}
//------------------------------
void s2(){
int t1 = 10;
ApagaTodos();
//Acende um por um.
for (int i=0; i<totalSaidas; i++){
mega.shiftWrite(led[i],HIGH);
delay(t1);
}
//Apaga um por um.
for (int i=0; i<totalSaidas-1; i++){
mega.shiftWrite(led[i],LOW);
delay(t1);
}
//Acende um por um. (inverso)
for (int i=totalSaidas-1; i>=0; i--){
mega.shiftWrite(led[i],HIGH);
delay(t1);
}
//Apaga um por um. (inverso)
for (int i=totalSaidas-1; i>0; i--){
mega.shiftWrite(led[i],LOW);
delay(t1);
}
}
//------------------------------
void s3(){
//ABRE E FECHA.
int t1 = 10;
ApagaTodos();
for (int i=0; i<totalSaidas/2; i++){
mega.shiftWrite(led[i],HIGH);
mega.shiftWrite(led[totalSaidas-1-i],HIGH);
delay(t1);
}
for (int i=0; i<(totalSaidas/2)-1; i++){
mega.shiftWrite(led[i],LOW);
mega.shiftWrite(led[totalSaidas-1-i],LOW);
delay(t1);
}
for (int i=(totalSaidas/2)-2; i>=0; i--){
mega.shiftWrite(led[i],HIGH);
mega.shiftWrite(led[totalSaidas-1-i],HIGH);
delay(t1);
}
for (int i=(totalSaidas/2)-1; i>0; i--){
mega.shiftWrite(led[i],LOW);
mega.shiftWrite(led[totalSaidas-1-i],LOW);
delay(t1);
}
}
//------------------------------
void s4(){
//POLÍCIA
int t1 = 1;
ApagaTodos();
//Lado 1 acesso. (piscando)
for (int j=0; j<totalSaidas/4; j++){
for (int i=0; i<totalSaidas/2; i++){
mega.shiftWrite(led[i],HIGH);
}
delay(t1);
for (int i=0; i<totalSaidas/2; i++){
mega.shiftWrite(led[i],LOW);
}
delay(t1);
}
//Lado 2 acesso. (piscando)
for (int j=0; j<totalSaidas/4; j++){
for (int i=totalSaidas/2; i<totalSaidas; i++){
mega.shiftWrite(led[i],HIGH);
}
delay(t1);
for (int i=totalSaidas/2; i<totalSaidas; i++){
mega.shiftWrite(led[i],LOW);
}
delay(t1);
}
}
//------------------------------
void s5(){
//FLASHS UM POR UM
int t1 = 5;
int t2 = 50;
ApagaTodos();
for (int i=0; i<totalSaidas; i++){
mega.shiftWrite(led[i],HIGH);
delay(t1);
mega.shiftWrite(led[i],LOW);
delay(t2);
}
}
//------------------------------
void s6(){
//FLASHS RANDOMICOS
randomSeed(analogRead(0)); //Para o random nao repetir a sequencia.
int t1 = 10;
int t2 = 40;
int p = random(totalSaidas);
ApagaTodos();
for (int i=0; i<35; i++){
mega.shiftWrite(led[p],HIGH);
delay(t1);
mega.shiftWrite(led[p],LOW);
delay(t2);
p = random(totalSaidas);
}
}
//------------------------------
void s7(){
int t1 = 1;
for (int i=0; i<2; i++){
AcendeTodos();
delay(t1);
ApagaTodos();
delay(500);
}
}
//------------------------------
void s8(){
//CORRE NUM EFEITO MEIO 3D. :)
int t1 = 10;
ApagaTodos();
for (int i=1; i<totalSaidas; i++){
mega.shiftWrite(led[i-2],LOW);
mega.shiftWrite(led[i-1],LOW);
mega.shiftWrite(led[i],HIGH);
delay(t1);
mega.shiftWrite(led[i],LOW);
mega.shiftWrite(led[i-1],HIGH);
delay(t1);
}
}
//------------------------------
void s9(){
int t1 = 100;
for (int x=0; x<3; x++){
for (int i=0; i<totalSaidas; i++){
if (i%2 == 0){
mega.shiftWrite(led[i],HIGH);
}
else{
mega.shiftWrite(led[i],LOW);
}
}
delay(t1);
for (int i=0; i<totalSaidas; i++){
if (i%2 == 0){
mega.shiftWrite(led[i],LOW);
}
else{
mega.shiftWrite(led[i],HIGH);
}
}
delay(t1);
}
}
//------------------------------
void s10(){
int t1 = 3;
int t2 = 100;
ApagaTodos();
delay(t2);
for (int x=0; x<totalSaidas; x++){
for (int i=0; i<totalSaidas-x; i++){
if (i != 0){
mega.shiftWrite(led[i-1],LOW);
}
mega.shiftWrite(led[i],HIGH);
delay(t1);
}
}
delay(t1);
mega.shiftWrite(led[0],HIGH);
delay(t2);
for (int x=0; x<totalSaidas; x++){
for (int i=0; i<totalSaidas-x; i++){
if (i != 0){
mega.shiftWrite(led[i-1],HIGH);
}
mega.shiftWrite(led[i],LOW);
delay(t1);
}
}
delay(t1);
mega.shiftWrite(led[0],LOW);
delay(t1);
}
Segue o código do exemplo do vídeo, e o esquema elétrico é o mesmo do post antigo.
Abraços e inté!
/*---------------------------------------------
S H I F T O U T M E G A
Ampliar o número de saídas do Arduino com
Registrador de Deslocamento 74HC595
Fellipe Couto - 17/09/2012
--------------------------------------------*/
/*¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨
- Pino 8 do Arduino ligado ao pino 12 do CI.
- Pino 11 do Arduino ligado ao pino 14 do CI.
- Pino 12 do Arduino ligado ao pino 11 do CI.
- Led 1 = Pino 15 do CI.
- Led 2 = Pino 1 do CI.
- Led 3 = Pino 2 do CI.
- Led 4 = Pino 3 do CI.
- Led 5 = Pino 4 do CI.
- Led 6 = Pino 5 do CI.
- Led 7 = Pino 6 do CI.
- Led 8 = Pino 7 do CI.
- Pinos 10 e 16 do CI ligados ao Vcc.
- Pinos 8 e 13 do CI ligados ao GND.
- Pino 9 do CI ligado ao pino 14 do próximo CI.
¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨*/
#include <ShiftOutMega.h> //Inclui a bilioteca ShiftOutMega.h
//Variáveis de uso dos registradores 74HC595
int latchPin = 8; //Pino 8 conectado ao pino 12 do 74HC595 (Latch).
int dataPin = 11; //Pino 11 conectado ao pino 14 do 74HC595 (Data).
int clockPin = 12; //Pino 12 conectado ao pino 11 do 74HC595 (Clock).
//Quantidade de registradores (74HC595). Para cada registrador, temos 8 saídas.
int qtdRegistradores = 3;
int totalSaidas = qtdRegistradores * 8;
//Inicia a biblioteca passando os parametros de uso.
ShiftOutMega mega(latchPin, dataPin, clockPin, qtdRegistradores);
void setup(){
}
void loop(){
s1();
s2();
s3();
}
void s1(){
int t = 5;
for (int x=0; x<5; x++){
for (int i=1; i<=totalSaidas; i++){
mega.shiftWrite(i, HIGH);
delay(t);
mega.shiftWrite(i, LOW);
delay(t);
}
for (int i=totalSaidas; i>=1; i--){
mega.shiftWrite(i, HIGH);
delay(t);
mega.shiftWrite(i, LOW);
delay(t);
}
t--;
}
}
void s2(){
int t = 10;
for (int x=0; x<5; x++){
for (int i=1; i<=totalSaidas; i++){
mega.shiftWrite(i, HIGH);
delay(t);
}
for (int i=1; i<=totalSaidas; i++){
mega.shiftWrite(i, LOW);
delay(t);
}
}
}
void s3(){
int t = 20;
for (int x=0; x<5; x++){
for (int i=1; i<=totalSaidas/2; i++){
mega.shiftWrite(i, HIGH);
mega.shiftWrite(totalSaidas+1-i, HIGH);
delay(t);
}
for (int i=totalSaidas/2; i>=1; i--){
mega.shiftWrite(i, LOW);
mega.shiftWrite(totalSaidas+1-i, LOW);
delay(t);
}
}
}
E aí, pessoal!
Um efeito bacana com dois Leds RGB.
Coloquei um pequeno intervalo de tempo entre as transições de cores em cada led para tentar criar um efeito de fade. O circuito é composto apenas por seis resistores de 220 ohms, dois LEDs RGB (catodo comum), e um circuito Arduino.
Segue o diagrama e o código fonte:
/*--------------
LED RGB
FELLIPE COUTO
07/07/2012
--------------*/
#define Red1 3
#define Red2 9
#define Green1 5
#define Green2 10
#define Blue1 6
#define Blue2 11
int RedOld = 0;
int GreenOld = 0;
int BlueOld = 0;
int RedOld2 = 0;
int GreenOld2 = 0;
int BlueOld2 = 0;
void setup(){
pinMode(Red1, OUTPUT);
pinMode(Red2, OUTPUT);
pinMode(Green1, OUTPUT);
pinMode(Green2, OUTPUT);
pinMode(Blue1, OUTPUT);
pinMode(Blue2, OUTPUT);
randomSeed(analogRead(0)); //Para o random não repetir a sequencia.
Pisca();
}
void loop(){
Pisca();
SequenciaRapida();
SequenciaAleatoria();
}
void SequenciaAleatoria(){
for (int i=0; i<15; i++){
CoresRGB(random(7) + 1, random(250) + 50); //fade = 50 a 299.
delay(40000);
}
}
void SequenciaRapida(){
for (int j=0; j<3; j++){
for (int i=1; i<=7; i++){
CoresRGB(i, 10);
delay(2000);
}
}
}
void Pisca(){
for (int i=1; i<=30; i++){
CoresRGB(random(8), 0);
delay(random(150));
}
}
void CoresRGB(int cor, int fade){
/*
0- APAGADO
1- VERMELHO
2- VERDE
3- AZUL
4- VERMELHO+AZUL
5- VERDE+AZUL
6- VERMELHO+VERDE
7- VERMELHO+VERDE+AZUL
*/
for (int i=0; i<=365; i++){
/* -- LED 1 -- */
switch(cor){
case 0:
RedOld--;
GreenOld--;
BlueOld--;
break;
case 1:
RedOld++;
GreenOld--;
BlueOld--;
break;
case 2:
RedOld--;
GreenOld++;
BlueOld--;
break;
case 3:
RedOld--;
GreenOld--;
BlueOld++;
break;
case 4:
RedOld++;
GreenOld--;
BlueOld++;
break;
case 5:
RedOld--;
GreenOld++;
BlueOld++;
break;
case 6:
RedOld++;
GreenOld++;
BlueOld--;
break;
case 7:
RedOld++;
GreenOld++;
BlueOld++;
break;
}
if (RedOld > 255){
RedOld = 255;
}
else if (RedOld < 0) {
RedOld = 0;
}
if (GreenOld > 255){
GreenOld = 255;
}
else if (GreenOld < 0) {
GreenOld = 0;
}
if (BlueOld > 255){
BlueOld = 255;
}
else if (BlueOld < 0) {
BlueOld = 0;
}
if (RedOld <= 255 && RedOld >= 0){
analogWrite(Red1, RedOld);
}
if (GreenOld <= 255 && GreenOld >= 0){
analogWrite(Green1, GreenOld);
}
if (BlueOld <= 255 && BlueOld >= 0){
analogWrite(Blue1, BlueOld);
}
/* -- LED 2 -- */
if (i >= 110){
switch(cor){
case 0:
RedOld2--;
GreenOld2--;
BlueOld2--;
break;
case 1:
RedOld2++;
GreenOld2--;
BlueOld2--;
break;
case 2:
RedOld2--;
GreenOld2++;
BlueOld2--;
break;
case 3:
RedOld2--;
GreenOld2--;
BlueOld2++;
break;
case 4:
RedOld2++;
GreenOld2--;
BlueOld2++;
break;
case 5:
RedOld2--;
GreenOld2++;
BlueOld2++;
break;
case 6:
RedOld2++;
GreenOld2++;
BlueOld2--;
break;
case 7:
RedOld2++;
GreenOld2++;
BlueOld2++;
break;
}
if (RedOld2 > 255){
RedOld2 = 255;
}
else if (RedOld2 < 0) {
RedOld2 = 0;
}
if (GreenOld2 > 255){
GreenOld2 = 255;
}
else if (GreenOld2 < 0) {
GreenOld2 = 0;
}
if (BlueOld2 > 255){
BlueOld2 = 255;
}
else if (BlueOld2 < 0) {
BlueOld2 = 0;
}
if (RedOld2 <= 255 && RedOld2 >= 0){
analogWrite(Red2, RedOld2);
}
if (GreenOld2 <= 255 && GreenOld2 >= 0){
analogWrite(Green2, GreenOld2);
}
if (BlueOld2 <= 255 && BlueOld2 >= 0){
analogWrite(Blue2, BlueOld2);
}
}
delay(fade);
}
}
