sábado, 20 de febrero de 2016

Arduino - Sensor HC-SR04

En esta ocasión vamos ha ver como funciona y se usa el sensor ultrasónico HC-SR04.



    1- Funcionamiento:



El sensor dispone de un emisor y un receptor.
*No se cual es cual exactamente ,quedaros con que tiene un receptor y un emisor.


El pin Trig controla el emisor y el Echo el receptor, la distancia que tarda es el tiempo que tarada en ir y venir/2/29, se divide entre dos por que la onda sale del Emisor(Trig) y vuelve por el receptor(Echo).




Nosotros solo queremos la distancia hacia el objeto, una vez dividido el resultado lo dividimos entre la velocidad del sonido en cm/microsegundos es decir 29.



  2-Caractersitcas:

  • Número de pines 4:
         VCC: Alimentación +5V (4.5V min – 5.5V max)
         TRIG: Trigger entrada (input) del sensor (TTL)
                 ECHO: Echo salida (output) del Sensor (TTL)
          GND
  • Corriente de reposo: < 2mA.
  • Corriente de trabajo: 15mA.
  • Ángulo de medición: 30º (Efectivo: < 15º).
  • Detección de 2cm a 400cm  (Sirve a más de 4m, pero no se garantiza una buena medición).
  •  La precisión puede variar entre los 3mm o 0.3cm.
  • Dimensiones: 45mm x 20mm x 15mm.
  • Frecuencia de trabajo: 40KHz.



      


   3-Conexion:




1-Conectamos  GND de Arduino a el GND del sensor y lo mismo con 5v.

2-Ahora conectamos el trig y el echo a a 2 pines digitales (en mi caso 2 y 3).

Ya esta ¿era simple no?.




4-Codigo para Arduino sin libreria:
*El código esta configurado para mandarte la medición si solo la quieres para las condicionales(If) puedes quitar lo que este en *



      //Usamos define para hacer una constante que no guarda datos
#define Trig 2     //Definimos el pin Trig
#define Echo 3              //Definimos el pin Echo
int duracion;               //Creamos una variable para guardar la duracion del pulso
int distancia;      //Creamos una variable para guardar la distancia 
void setup() {
  Serial.begin(9600);    //*
  pinMode(Trig,OUTPUT);
  pinMode(Echo,INPUT);
}

void loop() {

            digitalWrite(Trig, LOW);              //Apagamos Trig para comprobar que esta apagado     
            delayMicroseconds(2);               //Esperamos        
            digitalWrite(Trig, HIGH);             //Enecendemos Trig     
            delayMicroseconds(10);             //Esperamos
            digitalWrite(Trig, LOW);              //Apagamos Trig     
            duracion = pulseIn(Echo, HIGH); //Leemos el tiempo que tardo la onda con pulseIn()
            distancia = duracion / 2 / 29  ;      //Hacemos una operación para pasarlo a una distancia(Cm)
          
            delay(1000);                    //* Esperamos


Serial.print("distancia");                //*
Serial.print(distancia);                  //*
Serial.println("cm");                     //*
Serial.println();                            //*
}



5-Codigo para Arduino con librería NewPing.

Si no la tienes la puedes descargar aquí.

Con la libreria es muy fácil, solo hay que poner   15 lineas de código.
 *El código esta configurado para mandarte la medición si solo la quieres para las condicionales(If) puedes quitar lo que este en *



#include <NewPing.h>           //Incluimos la libreria

int Trig = 2;                                  //Declaramos Trig.
int Echo = 3;                                //Declaramos Echo.
NewPing Sonar(trig,echo,500);  //Ponemos nombre al sensor (sonar),definimos a que pin corresponden (Trig y Echo) y la distancia maxima que pueda leer.            
int distancia;                                //Creamos una variable para la distancia.

void setup(){
     pinMode(Trig,OUTPUT);
     pinMode(Echo,INPUT);
     Serial.begin(9600);                   //Iniciamos la comunicación serial.*
}

void loop(){
distancia = Sonar.ping_cm();           //Distancia sera igual a el valor del Sonar en Cm.
Serial.print("Distancia");  //*
Serial.print(distancia);      //*
Serial.println("cm");        //* 
Serial.println();                //*
delay(1000);                    //*
}


Arduino - Luces automáticas para tu casa

Hola, en esta primera entrada les voy a mostrar como hacer que unas luces se enciendan automáticamente al pasar con Arduino.

        -Materiales:
   Arduino UNO/Mega/Nano o similar.
   2 sensores ultrasónicos HC-SR04
   Un relé(Yo puse un Led pero simplemente es conectar un  rele en vez de el Led).




      -Aqui os dejo el esquema  y una explicación de colocación de componentes.




      1-Colocamos los sensores ultrasónicos en una protoboard ,o si lo van a incluir en su casa en un PCB.
      2-Ahora conectamos GND y 5V de Arduino con los sensores, después conectamos los pines trig y echo de los sensores a los pines digitales que queramos (en mi caso trig1 pin 7,echo1 pin 8 , trig 2 pin 12 y echo 2 pin 12).

      3-Una vez colocados los sensores colocamos en el lugar del Led  un relé 5V( con diodos  para no quemar el Arduino con corrientes inversas), un pin de el relé va a una salida digital y el otro a GND.


 -Funcionamiento de los sensores.
       En este caso usaremos la librería NewPing, así que no haría falta saber como funciona el sensor, pero si  no quieres usar la librería para controlar estos sensores lo explico:

El sensor funciona midiendo el tiempo  que tarda la onda desde que tu la mandas mediante el pin trig hasta que vuelve en el pin echo, así que seria así.

Como el pin trig es el que manda la señal de sonido cuando tu quieras accionarlo, empezaríamos el sketch de Arduino poniendo el siguiente código:

                                                                                                                                                                          
                                                                                                                                                                                
 void loop(){                                                                                                                                                        
digitalWrite(trig,LOW);                                                                                                                                    
delayMicroseconds(2);                                                                                                                                    
digitalWrite(trig,HIGH);                                                                                                                            
delayMicroseconds(10);                                                                                                                                    
digitalWrite(trig,LOW);                                                                                                                                    
}                                                                                                                                                                                
                                                                                                                                                                                 


Primero nos aseguramos de que esta apagado el sensor poniéndolo en LOW, después esperamos 2 microsegundos y ya accionamos el pin trig para mandar la onda, lo siguiente seria dejarle un tiempo a que reboten las ondas, y finalmente apagar el sensor.  Ahora hay que medir el tiempo que tardan las ondas en ir y venir así que  usamos la función "pulseIn" guardando el resultado en una variable (llamada duración  en mi caso).


                                                                                                                                                                                
duración = pulseIn(echo,HIGH);                                                                                                                                    
                                                                                                                                                                                


Ya una vez guardado el tiempo seria hacer una simple operación matemática, el tiempo que ha tardado al onda en volver / velocidad del sonido en  cm por microsegundo / 2 por que las ondas van y vuelven, así que si no lo dividiéramos la distancia seria el doble de la que es:


                                                                                                                                                                                
distancia = duración/29,1/2                                                                                                                                    
                                                                                                                                                                                

Y ya si queremos ver en el ordenador la distancia que mide el sensor usaríamos la comunicación serial, así que quedaría algo así:


 int trig = 2;    //Conectaríamos el pin trig en el 2(o cambiamos el pin en el que esta trig)                                     
int echo =4;   //Conectaríamos el pin echo en el 4(o cambiamos el pin en el que esta echo)                     
int distancia;                                                                                                                                                         
int duración;                                                                                                                                                         
                                                                                                                                                                                
void setup(){                                                                                                                                                        
pinMode(trig,OUTPUT);                                                                                                                                    
pinMode(echo,INPUT);                                                                                                                                    
Serial.begin(9600);                                                                                                                                                          
}                                                                                                                                                                                      
                                                                                                                                                                                
void loop(){                                                                                                                                                                     
digitalWrite(trig,LOW);                                                                                                                                    
delayMicroseconds(2);                                                                                                                              
digitalWrite(trig,HIGH);                                                                                                                             
delayMicroseconds(10);                                                                                                                             
digitalWrite(trig,LOW);                                                                                                                               
duración = pulseIn(echo,HIGH);                                                                                                                           
distancia = duración/29,1/2                                                                                                                           
Serial.print(distancia);                                                                                                                                
// Se puede poner un delay aquí para poder leer la medida.                                                                                  
}                                                                                                                                                                 
                                                                                                                                                                    


     -Programa
Yo repito, les voy a dar  el sketch con la librería NewPing así que tienen que descargársela, sin la libreria se las apañan ustedes con el código que he dado antes.




#include <NewPing.h>                                                                                                                                        
const int Trig1 = 7;                                                                                                                                        
const int Echo1 = 8;                                                                                                                                        
const int Trig2 = 12;                                                                                                                                        
const int Echo2 = 11;                                                                                                                                        
int personas = -1;           //Aqui guardaremos el nuero de personas que hay en la habtación.                                  
int distancia1;                                                                                                                                                         
int distancia2;                                                                                                                                                         
int duracion1;                                                                                                                                                         
int Led = 2;                                                                                                                                                         
int estado = 0;                                                                                                                                                         
int estadoAnterior ;                                                                                                                                        
NewPing Sonar2(Trig2,Echo2,500);                                                                                                                       
                                                                                                                                                                          
void setup() {                                                                                                                                                         
 pinMode(Trig1,OUTPUT);                                                                                                                       
 pinMode(Trig2,OUTPUT);                                                                                                                                      
 pinMode(Echo1,INPUT);                                                                                                                                        
 pinMode(Echo2,INPUT);                                                                                                                                        
 pinMode(Led,OUTPUT);             //Declaramos que el pin Led o rele sera una salida.                                             
Serial.begin(9600);                                                                                                                                        
}                                                                                                                                                                          
                                                                                                                                                                          
void loop() {                                                                                                                                                         
 digitalWrite(Trig1, LOW);                                                                                                                                        
 digitalWrite(Trig2, LOW);                                                                                                                               
            delayMicroseconds(2);                                                                                                                    
            digitalWrite(Trig1, HIGH);                                                                                                              
            delayMicroseconds(10);                                                                                                                   
            digitalWrite(Trig1, LOW);                                                                                                                            
            duracion1 = pulseIn(Echo1, HIGH);                                                                                                      
            distancia1 = duracion1 / 2 / 29.1 ;                                                                                                      
            if(distancia1 < 0){                                                                                                                                        
              distancia1 = distancia1 + distancia1;                                                                                                      
                                                                                                                                                                       
              }                                                                                                                                                         
            distancia2 = Sonar2.ping_cm();                                                                                                      
    if(distancia1 >60 && distancia2 <60 ){  //Si la distancia1 es mayor 60 y la 2 es menor a 60.                        
     delay(1000);                                                                                                                                        
    estado = 1;                               //Estado es 1.                                                                                                  
    personas = personas + 1;                //Y sumamos una persona a la sala.                                                   
                                                                                                                                                                              
    }                                                                                                                                                                          
    if(distancia2 >60 && distancia1 <60){   //Si la distancia2 es mayor 60 y la 2 es menor a 60.               
     delay(1000);                                                                                                                                                         
      estado= 0;                            //Estado es 0.                                                                                                      
      personas = personas - 1;              //Y restamos una persona a la sala.                                                   
      if(personas < 0){                     //Por si alguien intenta hacer  que las personas sean negativas                  evitando el sensor al entrar ,cuando las personas sean menor a 0.                                                                     
        personas = 0;                       //Personas sera 0.                                                                                     
        }                                                                                                                                                         
                                                                                                                                                                                
      }                                                                                                                                                                          
  if(estado == 1){                          //Si estado es 1.                                                                                                    
    digitalWrite(Led,HIGH);                 //Encendemos el Led/Relé.                                                                    
    }                                                                                                                                                                          
  if(estado == 0 && personas == 0){         //Si estado es 0 y hay 0 personas en la sala.                                
    digitalWrite(Led,LOW  );                //Apagamos el Led/Relé.                                                                    
    }                                                                                                                                                                          
                     
        Serial.println("personas");//Si quieres un contador deparsonas aqui lo tienes.
       Serial.println(personas);
  }
         

      
      
    
        
El contador de personas es por si entra alguien a tu cuarto y sale no se apague la luz y te deje a oscuras   xD



Gracias,por haber leido la entrada. 


Si no les funciona decírmelo ,por que por ejemplo a mi uno de los sensores me media mal con la librería así que lo hice sin la librería como podéis ver arriba.