Escada Inteligente - A realização de um sonho

oi pessoal!

terminei meu projeto e gostaria de compartilha-lo com vocês: 

https://www.youtube.com/watch?v=-wserskaiia

peças
15 leds de alto brilho,
2 protoboards
1 arduino
1 fonte
30 metros de cabo de rede
2 sensores ultrasonico

segue código fonte:

code: [select]


/*---------------------------------------------
s h f t o u t m e g a
ampliar o número de saídas arduino com
registrador de deslocamento 74hc595
--------------------------------------------*/

/*¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨
- pino 8 arduino ligado ao pino 12 ci.
- pino 11 arduino ligado ao pino 14 ci.
- pino 12 arduino ligado ao pino 11 ci.
- led 1 = pino 15 ci.
- led 2 = pino 1 ci.
- led 3 = pino 2 ci.
- led 4 = pino 3 ci.
- led 5 = pino 4 ci.
- led 6 = pino 5 ci.
- led 7 = pino 6 ci.
- led 8 = pino 7 ci.
- pinos 10 e 16 ci ligados ao vcc.
- pinos 8 e 13 ci ligados ao gnd.
- pino 9 ci ligado ao pino 14 próximo ci.
¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨*/

#include <shiftoutmega.h> //inclui biblioteca shiftoutmega.h
#include <newping.h> // inclui biblioteca newping.h

//variáveis de uso dos registradores 74hc595
int latchpin = 8;  //pino 8 conectado ao pino 12 74hc595 (latch).
int datapin = 11;  //pino 11 conectado ao pino 14 74hc595 (data).
int clockpin = 12; //pino 12 conectado ao pino 11 74hc595 (clock).

//define o numero de sensores, distancia maxima e o intervalo da medição
#define sonar_num   2 // define o numero de sensores 
#define max_distance 80 // distancia maxima 
#define ping_interval 33 // milisegundos de intervalo entre medicoes (29ms e o tempo mínimo para evitar conflito entre os sensores)

unsigned long pingtimer[sonar_num]; // armazena quantidade de vezes que medicao deve ocorrer, para cada sensor 
unsigned int cm[sonar_num];     // armazena o numero de medicoes 
uint8_t currentsensor = 0;     // armazena o sensor que esta ativo 

//criando objeto e definindo portas digitais trigger - 6 - e echo - 7

newping sonar[sonar_num] =   
{   // armazena informacoes sobre pinagem dos sensores 
  newping(6, 7, max_distance), // pino trigger, echo e distancia máxima, para cada sensor 
  newping(3, 4, max_distance), 
}; 

//quantidade de registradores (74hc595). para cada registrador, temos 8 saídas.
int qtdregistradores = 2;

int totalsaidas = qtdregistradores * 8;
int t = 100; //tempo entre o acender dos leds.
int tempo = 2000; //tempo que fica aceso os leds para depois apagar.

//inicia biblioteca passando os parametros de uso.
shiftoutmega mega(latchpin, datapin, clockpin, qtdregistradores);

void setup(){
serial.begin(9600); //inicializando o serial monitor 
  pingtimer[0] = millis() + 75;      //primeira medicao começa com 75ms 
  (uint8_t = 1; < sonar_num; i++) //define o tempo de inicializacao de cada sensor 
   pingtimer[i] = pingtimer[i - 1] + ping_interval;

     //apagando todos os leds
  mega.shiftwrite(totalsaidas, low);
}

void loop() { 
  (uint8_t = 0; < sonar_num; i++) { // loop entre todos os sensores 
   if (millis() >= pingtimer[i]) {       
    pingtimer[i] += ping_interval * sonar_num; //define o tempo que o proximo sensor sera acionado 
    if (i == 0 && currentsensor == sonar_num - 1) onesensorcycle(); // ciclo sensor completo 
    sonar[currentsensor].timer_stop();     // reseta o timer antes de ler o proximo sensor 
    currentsensor = i;             // número sensor sendo acionado   
    cm[currentsensor] = 0;           // se nao houver eco sensor, seta distância como zero 
    sonar[currentsensor].ping_timer(echocheck); 
   } 
} 
}
void echocheck() { //se receber um sinal (eco), calcula distancia 
  if (sonar[currentsensor].check_timer()) 
   cm[currentsensor] = sonar[currentsensor].ping_result / us_roundtrip_cm; 
}   

void onesensorcycle() { // ciclo de leitura sensor
     
//se detectado objeto entre 0 e 10 cm sensor1, acende leds
     if (cm[0] > 1 && cm[0] < 10){
       
    (int i=1; i<=totalsaidas; i++){
      mega.shiftwrite(i, high);
      delay(t);
    }
    delay(tempo);
    (int i=1; i<=totalsaidas; i++){
      mega.shiftwrite(i, low);
      delay(t);
    }
   }
//se detectado objeto entre 0 e 50 cm sensor2, acende o led   
     if (cm[1] > 1 && cm[1] < 10) {
    (int i=1; i<=totalsaidas; i++){
      mega.shiftwrite(totalsaidas+1-i, high);
      delay(t);
    }
    delay(tempo);
    (int i=1; i<=totalsaidas; i++){
      mega.shiftwrite(totalsaidas+1-i, low);
      delay(t);   
  }
}
}


o desenho projeto ainda não tenho pronto. quando terminar eu add aqui.

abraço!

gostei de ver, parabéns
tenho uma sugestão para ti,
qual o comportamento se eu correr e subir escada?
devias obter velocidade de quem sobe ou desce e com base nesse valor regular velocidade dos leds de acender e apagar.
se fosse devagar os leds acompanham -me , mas se depressa eles também o fazem de uma forma dinâmica.
assim da um efeito mais natural
se tens sensores ultra-sónicos consegues obter velocidade em metros/segundo que o utilizador passou e com base nisso definires uma velocidade aos leds.

Arduino Forum > International > Portugues > Escada Inteligente - A realização de um sonho

arduino