20 de fevereiro de 2016

Capacitor de Fluxo


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);
  }
}

29 de junho de 2014

MemoryLib.h EEPROM

Vamos falar um pouco sobre a memória EEPROM.

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.

O download pode ser feito através desses links:
http://www.4shared.com/rar/k1GDZl5Zce/MemoryLib.html
https://mega.co.nz/#!aAc2BQ7K!j-7kM4cWO_-_kOntkCeYVHFwO1sitKxjcNGfyqcSwmc

Junto com a biblioteca tem os exemplos de uso para não ter dúvidas.

É isso! Espero que seja útil!
Abraços!

5 de maio de 2014

Mira Laser


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);
  }
}

11 de abril de 2014

Genius (Simon Game)


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;
    }
  }
} 

10 de abril de 2014

Sensor de Vagas


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);
  }
} 

8 de abril de 2014

Seguidor de Luz


Esse é o Batman seguidor de luz!

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++);
  }
}

25 de agosto de 2013

Relógio Binário


Vamos exercitar a cachola e visualizar as horas no relógio binário!

Como já está mostrando no vídeo, as horas são exibidas pela primeira fileira de leds, no meio exibe os minutos, e a última os segundos.

Temos dois push-buttons no circuito para o ajuste de horas e minutos.

Segue o esquema elétrico e o código fonte.

 /*--------------
 RELOGIO BINARIO
 Fellipe Couto
 11/05/2013
 --------------*/

/*----- VARIAVEIS -----*/
long previousMillis = 0;
long interval = 1000;
int hour = 0;
int minute = 0;
int second = 0;
int ledHour[5] = {1,2,3,4,5}; //Leds das horas
int ledMinute[6] = {6,7,8,9,10,11}; //Leds dos minutos
int ledSecond[6] = {12,13,14,15,16,17}; //leds dos segundos

/*----- SETUP -----*/
void setup(){
  for (int i=0; i<5; i++){
    pinMode(ledHour[i], OUTPUT);
  }
  for (int i=0; i<6; i++){
    pinMode(ledMinute[i], OUTPUT);
    pinMode(ledSecond[i], OUTPUT);
  }
}

/*----- LOOP PRINCIPAL -----*/
void loop(){
  unsigned long currentMillis = millis();

  //Intervalo de 1 segundo
  if (currentMillis - previousMillis > interval){
    previousMillis = currentMillis;

    clockDec(); //Relógio decimal
    clockBin(); //Relogio binario

    if (analogRead(4) == 1023){ //Ajuste de horas
      hour++;
      second = 0;
    }

    if (analogRead(5) == 1023){ //Ajuste de minutos
      minute++;
      second = 0;
    }
  }
}

/*----- RELOGIO DECIMAL -----*/
void clockDec(){
  second++;   
  if (second == 60){
    second = 0;
    minute++;
  }
  if (minute == 60){
    minute = 0;
    hour++;
  }
  if (hour == 24){
    hour = 0;
  }
}

/*----- RELOGIO BINARIO -----*/
void clockBin(){
  //Segundos
  for (int j=0; j<6; j++){
    if (decToBin(second, 6).substring(j,j+1) == "0"){
      digitalWrite(ledSecond[j], LOW);
    }
    else{
      digitalWrite(ledSecond[j], HIGH);
    }
  }
  //Minutos
  for (int j=0; j<6; j++){
    if (decToBin(minute, 6).substring(j,j+1) == "0"){
      digitalWrite(ledMinute[j], LOW);
    }
    else{
      digitalWrite(ledMinute[j], HIGH);
    }
  }
  //Horas
  for (int j=0; j<5; j++){
    if (decToBin(hour, 5).substring(j,j+1) == "0"){
      digitalWrite(ledHour[j], LOW);
    }
    else{
      digitalWrite(ledHour[j], HIGH);
    }
  }
}

/*----- CONVERTE DECIMAL PARA BINARIO -----*/
String decToBin(int num, int qtd){
  //Retorna uma string de 'qtd' posições.
  int zeros = qtd - String(num, BIN).length();
  String str;
  for (int i=0; i<zeros; i++){
    str = str + "0";
  }
  return str = str + String(num, BIN);        
}

24 de agosto de 2013

Luz Noturna


O sensor detectou pouca luminosidade no ambiente e os leds são acionados para não ficar aquela escuridão.

Circuito interessante pra ficar num lugar onde é necessário sempre um pouco luz para não sair tropeçando e batendo a cabeça.

Segue o esquema elétrico e o código fonte do microcontrolador.

É isso! Abraços!
 /*------------
 LUZ NOTURNA
 Fellipe Couto
 06/06/2013
 ------------*/
int led[3] = {3,5,6}; //Pinos dos Leds
int LDR = 0; //LDR ligado ao analog(0) com resistor pull-down de 10k
int ldrValue = 0;
int ldrMin = 100; //Valor LDR com luz apagada
int ldrMax = 800; //Valor LDR com luz acessa
boolean ledStatus = false;

void setup(){
  for (int j=0; j<3; j++){
    pinMode(led[j], OUTPUT);
  }
}

void loop(){
  delay(1000);
  ldrValue = analogRead(LDR); //Valor do LDR.
  
  if (ldrValue < ldrMin && ledStatus == false){
    ledOn();
  }
  if (ldrValue > ldrMax && ledStatus == true){
    ledOff();
  }
}

void ledOn(){
  ledStatus = true;
  for (int j=0; j<3; j++){
    for (int i=0; i<255; i++){
      analogWrite(led[j], i);
      delay(4);
    }
  }
  ldrMax = analogRead(LDR) + 120;
}

void ledOff(){
  ledStatus = false;
  for (int j=0; j<3; j++){
    for (int i=254; i>=0; i--){
      analogWrite(led[j], i);
      delay(4);
    }
  }
}

11 de fevereiro de 2013

Dado Eletrônico

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);
  }
}

31 de outubro de 2012

Safety Car

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);
  }
}

20 de outubro de 2012

Módulo Relé duplo - DIY

Alô meu povo!

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!

Abraços!

14 de outubro de 2012

Disco RGB - Sequencial 18 canais

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); 
    }
  }
}

26 de setembro de 2012

Sensor Laser


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);
}

22 de setembro de 2012

Contador de Passagem

O infravermelho detectou, o display contou!



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.
}

19 de setembro de 2012

Super Sequencial de LEDs

Fala meu povo! São 30 Leds no sequencial!


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.

Para mais informações sobre a biblioteca:
http://www.efeitonerd.com.br/2012/09/ampliar-saidas-do-arduino-library.html
E o download nesse link:
http://www.4shared.com/rar/QSUfwzo4/ShifOutMega.html

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);
} 

18 de setembro de 2012

Ampliar saídas do Arduino (Library)

Alô cientistas e computeiros! Seus problemas acabaram!
Esta pronta a biblioteca que vai permitir seu Arduino ter mais de 100 saídas!


Para entender melhor, vejam um post antigo que havia feito sobre esse assunto: http://www.efeitonerd.com.br/2012/02/ampliar-saidas-do-arduino.html

Nesse projeto, usei 3 registradores 74HC595 e apenas 3 saídas do Arduino. Para cada registrador, temos 8 novas saídas.

Fiz a biblioteca para controle individual de cada saída, exatamente da mesma forma que usamos o digitalWrite() do Arduino.

Como são 3 registradores, temos 24 saídas. Para acender o LED da saída número 20, por exemplo, usamos:
mega.shiftWrite(20, HIGH);
E para apaga-lo:
mega.shiftWrite(20, LOW);

A biblioteca ShiftOutMega pode ser baixada nesses links:
http://www.4shared.com/rar/QSUfwzo4/ShifOutMega.html
https://mega.co.nz/#!jMN1zJBB!zyo3lVibrMU6VTssYvimg-v1hVLtabX0DzncQm2rAlw
É só copiar para a pasta libraries do diretório do software Arduino.

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);
    }
  }
} 

7 de julho de 2012

LEDs RGB

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);
  }
}