Escada Inteligente - A realização de um sonho

Oi pessoal!

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

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:

/*---------------------------------------------
 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
 --------------------------------------------*/
 
/*¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨
 - 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 biblioteca ShiftOutMega.h
#include <NewPing.h> // Inclui a biblioteca NewPing.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).

//Define o numero de sensores, a 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 a quantidade de vezes que a 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 as portas digitais do Trigger - 6 - e Echo - 7

NewPing sonar[SONAR_NUM] =   
 {   // Armazena informacoes sobre a 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 a 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  
  for (uint8_t i = 1; i < 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() {  
  for (uint8_t i = 0; i < 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 do sensor completo  
    sonar[currentSensor].timer_stop();     // Reseta o timer antes de ler o proximo sensor  
    currentSensor = i;             // Número do sensor sendo acionado   
    cm[currentSensor] = 0;           // Se nao houver eco do sensor, seta a distância como zero  
    sonar[currentSensor].ping_timer(echoCheck);  
   }  
 }  
}
 void echoCheck() { //Se receber um sinal (eco), calcula a distancia  
  if (sonar[currentSensor].check_timer())  
   cm[currentSensor] = sonar[currentSensor].ping_result / US_ROUNDTRIP_CM;  
 }    
 
 void oneSensorCycle() { // Ciclo de leitura do sensor
     
//Se for detectado objeto entre 0 e 10 cm do sensor1, acende leds
     if (cm[0] > 1 && cm[0] < 10){
       
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(i, HIGH);
      delay(t);
    }
    delay(tempo);
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(i, LOW);
      delay(t);
    }
   }
//Se for detectado objeto entre 0 e 50 cm do sensor2, acende o led   
     if (cm[1] > 1 && cm[1] < 10) {
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(totalSaidas+1-i, HIGH);
      delay(t);
    }
    delay(tempo);
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(totalSaidas+1-i, LOW);
      delay(t);   
  }
 }
}

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

Abraço! :wink:

Gostei de ver, parabéns
Tenho uma sugestão para ti,
Qual o comportamento se eu for a correr e subir a escada?
Devias obter a velocidade de quem sobe ou desce e com base nesse valor regular a velocidade dos leds de acender e apagar.
Se fosse devagar os leds acompanham -me , mas se for 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 a velocidade em metros/segundo a que o utilizador passou e com base nisso definires uma velocidade aos leds.

Ola,

Tenho interesse no assunto ...

bobducs:
Oi pessoal!

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

Projeto Arduino - Escada Inteligente LED - Instalação final (smart stairs) - YouTube

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:

/*---------------------------------------------

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
--------------------------------------------*/

/*¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨

  • 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 biblioteca ShiftOutMega.h
#include <NewPing.h> // Inclui a biblioteca NewPing.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).

//Define o numero de sensores, a 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 a quantidade de vezes que a 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 as portas digitais do Trigger - 6 - e Echo - 7

NewPing sonar[SONAR_NUM] =   
{   // Armazena informacoes sobre a 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 a 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 
  for (uint8_t i = 1; i < 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() { 
  for (uint8_t i = 0; i < 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 do sensor completo 
    sonar[currentSensor].timer_stop();     // Reseta o timer antes de ler o proximo sensor 
    currentSensor = i;             // Número do sensor sendo acionado   
    cm[currentSensor] = 0;           // Se nao houver eco do sensor, seta a distância como zero 
    sonar[currentSensor].ping_timer(echoCheck); 
   } 

}
void echoCheck() { //Se receber um sinal (eco), calcula a distancia 
  if (sonar[currentSensor].check_timer()) 
   cm[currentSensor] = sonar[currentSensor].ping_result / US_ROUNDTRIP_CM; 
}

void oneSensorCycle() { // Ciclo de leitura do sensor
     
//Se for detectado objeto entre 0 e 10 cm do sensor1, acende leds
     if (cm[0] > 1 && cm[0] < 10){
       
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(i, HIGH);
      delay(t);
    }
    delay(tempo);
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(i, LOW);
      delay(t);
    }
   }
//Se for detectado objeto entre 0 e 50 cm do sensor2, acende o led   
     if (cm[1] > 1 && cm[1] < 10) {
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(totalSaidas+1-i, HIGH);
      delay(t);
    }
    delay(tempo);
    for (int i=1; i<=totalSaidas; i++){
      mega.shiftWrite(totalSaidas+1-i, LOW);
      delay(t);   
  }
}
}




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

Abraço! ;)

amigo conseguias colocar aqui o esquema ?
gostava muito de fazer também este projecto.

obrigado

Parabéns , muito bom.

A pergunta que fiz logo assim que vi foi a mesma que a do HugoPT acima, se eu for a correr o que acontece? :slight_smile: deverá ser só uma questão de adaptar o projecto para esta situação

por favor malta , ninguém consegue arranjar o esquema deste projecto ?

obrigado

Muito bom, parabéns! E obrigado por partilhar.

Muitooo legal, excelente ideia :smiley:
Já encomendei 4 sensores, vou implementar a ideia do HugoPT. usando 2 sensores no alto, e 2 sensores embaixo da escada, medindo assim a velocidade da pessoa e acendendo dinamicamente os leds. Uma pena que tá demorando séculos para chegar encomendas internacionais no Brasil, mas com certeza lembrarei de compartilhar quando estiver pronto (entre 2 a 4 meses para chegar)

Não vou aguentar esperar chegarem meus sensores :sweat_smile:, achei um sensor infrared jogado aqui e vou implementar assim mesmo: Num lado o sensor infrared, do outro lado um interruptor (do tipo campainha). Vou comprar canaletas e cabo de rede neste final de semana para instalar. Quando os sensores ultrassom chegarem eu instalo no lugar e altero o software

Teste:

Esquemático:
Imgur

Código modificado para sensor e botão:

#define SENSOR1 A0 // Analog input pin that  is attached to the sensor
#define SENSOR2 8 //D8
#define ADC_REF 5//reference voltage of ADC is 5v.If the Vcc switch on the seeeduino
				 //board switches to 3V3, the ADC_REF should be 3.3


#define MAX_DISTANCE 1.0 // deve ser ajustado para distância de trigger desejada

float voltage;//the sensor voltage, you can calculate or find the distance
				// to the reflective object according to the figures
				//on page 4 or page 5 of the datasheet of the GP2Y0A21YK.


//Variáveis de uso dos registradores 74HC595
int latchPin = 10;  //Pino 8 conectado ao pino 12 do 74HC595 (Latch).
int dataPin = 11;  //Pino 11 conectado ao pino 14 do 74HC595 (Data).
int clockPin = 13; //Pino 12 conectado ao pino 11 do 74HC595 (Clock).

int totalSaidas = 16; // max 16
int t = 100; //tempo entre o acender dos leds.
int tempo = 2000; //tempo que fica aceso os leds para depois apagar. 

unsigned int leds;

void setup() 
{
  // initialize serial communications at 9600 bps:  
  Serial.begin(9600);
  
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(SENSOR2, INPUT_PULLUP); // porque é botao
  shiftWrite(0);
}
 
void loop() 
{
  leds=0;
  voltage = getVoltage();
  Serial.println(voltage);
  if(voltage > MAX_DISTANCE) {
    for (int i=0; i<=totalSaidas; i++){
      bitSet(leds, i);
      shiftWrite(leds);
      delay(t);
    }
    delay(tempo);
    for (int i=0; i<=totalSaidas; i++){
      bitClear(leds, i);
      shiftWrite(leds);
      delay(t);
    }
  }
    
  if (!digitalRead(SENSOR2))
  {
    for (int i=0; i<totalSaidas; i++){
      bitSet(leds, totalSaidas-i);
      shiftWrite(leds);
      //mega.shiftWrite(totalSaidas+1-i, HIGH);
      delay(t);
    }
        
    while(voltage < MAX_DISTANCE) {
      voltage = getVoltage();
    }
    
    for (int i=0; i<totalSaidas; i++){
      bitClear(leds, totalSaidas-1-i);
      shiftWrite(leds);
      //mega.shiftWrite(totalSaidas+1-i, LOW);
      delay(t);   
    }
    voltage = 0;
  }
    
  // wait 500 milliseconds before the next loop
  delay(100); 
}
/****************************************************************************/
/*Function: Get voltage from the sensor pin that is connected with analog pin*/
/*Parameter:-void      */
/*Return:	-float,the voltage of the analog pin      */
float getVoltage()
{
	int sensor_value;
	int sum;  
	// read the analog in value:
	for (int i = 0;i < 20;i ++)//Continuous sampling 20 times
	{
		sensor_value = analogRead(SENSOR1); 
		sum += sensor_value;
	}
	sensor_value = sum / 20;
	float voltage;
	voltage = (float)sensor_value*ADC_REF/1024;
	return voltage;
}

void shiftWrite(unsigned int _leds) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, _leds);
  shiftOut(dataPin, clockPin, MSBFIRST, _leds >> 8);
  digitalWrite(latchPin, HIGH);
}

Como prometido:
Como ficou o projeto adaptado > Escada iluminação Inteligente (smart stairs) - YouTube

Ficou muito engraçado!
Não percebi 2 coisas:
1- Os interruptores são os que já estavam na instalação, certo? (e foi aproveitada essa altura para colocar o sensor, não é?)
2- na parte de baixo não tem nenhum sensor ou o sensor é diferente? (vê-se uma pequena placa no vídeo, mas é diferente da de cima)

luisilva:
Ficou muito engraçado!
Não percebi 2 coisas:
1- Os interruptores são os que já estavam na instalação, certo? (e foi aproveitada essa altura para colocar o sensor, não é?)
2- na parte de baixo não tem nenhum sensor ou o sensor é diferente? (vê-se uma pequena placa no vídeo, mas é diferente da de cima)

Sim e sim :slight_smile:
Eu comprei os sensores ultrasonicos no ebay e vai demorar uns 3-4 meses para chegar. Para não ter que esperar improvisei com uma chave embaixo e um sensor IR em cima.

Ia colocar os sensores na altura dos pés para ficar mais discreto, mas tenho gatos em casa, seria um inferno com eles ativando o tempo todo a iluminação :sweat_smile:

Lembrei desse tópico.

Veja:
http://www.usinainfo.com.br/module/csblog/detailpost/134-79-stairlights-um-projeto-de-iluminacao-led-em-escada-baseado-em-arduino.html

Gostei muito do projeto do nosso amigo. Montei pra testar e montar na minha escada...mas achei que poderia ser feito algumas melhorias. Por exemplo se alguém subir e parar no meio do caminho, os leds vao se apagando com o tempo que foi definido. Uma solução seria quando passar pelo sensor1, os leds acendem e so se apagam se passar novamente pelo sensor1 ou quando passar pelo sensor2. Assim, enquanto a pessoa não sair da escada, ela nao vai apagar. Sou bem fraco na programação ainda, aí demoro muito pra chegar em um código otimizado. Algum amigo que tenha mais experiência poderia ajudar tentando fazer essa alteração no código?
Um abraço a todos

Muito bom seu trabalho.

Pode me enviar o esquemático?