Practica 09: Detectar personas que entran en

una fila
11 respuestas

Esta es la práctica 9 que funge como práctica integradora.

Objetivo:
Mediante el uso de un sensor ultrasonico detectaremos cuantas personas entran en una fila, y
se mostrara un display de 7 segmentos cuantas han entrado. Los dos LEDs serviran de apoyo
para dicho conteo.

Material necesario:
1 – Tarjeta ARDUINO UNO
1 – Cable USB para Arduino
1 – Tarjeta Protoboard
1 – Software IDE de Arduino + Libreria New Ping
1 Display de 7 segmentos de cátodo común, del color que deseen.
2 LED de diferente color
1 Sensor ultrasónico HC – SR04
9 resistencias 220 o 330 ohms.
Cables (los necesarios).

Descripción

1. Para comenzar conectamos un display de 7 segmentos a la Arduino.

2. Después tomando como referencia la siguiente imagen, conectamos una resistencia a
cada pin del display y basándonos en la letras asignadas de la resistencia conectamos
a los pines digitales de Arduino comenzando por el 2 (a-2, b-3, c-4, d-5, e-6, f-7, g-8)
3. Ahora el pin Com que está del lado del punto decimal se conecta a tierra.
 Diagrama de un display de 7 segmentos

4. Una vez conectado todo el cableado del display se procede a colocar el sensor
ultrasónico en la protoboard, Se conectan mediante cables los pines de tierra y
alimentación. Ahora el pin trigger (el que envía la sonda) lo conectamos al pin 12 de
nuestro Arduino y el pin echo(el que recibe la sonda) al pin 11.
5. También conectamos dos LEDs a nuestra protoboard, al igual que casos anteriores, se
usa una resistencia de 330 o 220 Ohm para conectar a tierra y al otro extremo del LED
se conecta un cable que ira conectado al pin 9 de Arduino y otro LED se conecta al pin
10.
6. Terminada la conexión se procede a cargar el código para así finalizar.

Esquema de conexión de la práctica, realizado en Fritzing

Código

/*Practica 09 (Integradora)
Se cuentan cuantas personas entran en una fila y se muestra la cantidad en un display*/
// SE importa la libreria NewPing
#include <NewPing.h>
// Se crea un objeto con la libreria NewPing llamado sonar
NewPing sonar(12, 11, 200); // Each sensor's trigger pin, echo pin, and max distance
to ping.

/* se declaran las contantes para identificar cada led*/

const int a = 2;
const int b = 3;
const int c = 4;
const int d = 5;
const int e = 6;
const int f = 7;
const int g = 8;
/* Contadores */
int cuenta =0;
int cuenta2 =0;
int cuenta3 =0;

int distancia;
int pausa;

/* Metodo para elegir que numero mostrar en el display*/

void actualizarNumero(){
switch (cuenta) {
case 0:
/*Bloque para mostrar un 0*/
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
break;
case 1:
/*Bloque para mostrar un 1*/
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 2:
/*Bloque para mostrar un 2*/
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
break;
case 3:
/*Bloque para mostrar un 3*/
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
break;
case 4:
/*Bloque para mostrar un 4*/
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
 digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 5:
/*Bloque para mostrar un 5*/
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 6:
/*Bloque para mostrar un 6*/
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 7:
/*Bloque para mostrar un 7*/
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
break;
case 8:
/*Bloque para mostrar un 8*/
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
break;
case 9:
/*Bloque para mostrar un 9*/
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);

}
}
void setup(){
/*Declaramos los segmetos del display como salidas*/
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
pinMode(9, OUTPUT); //led azul
pinMode(10, OUTPUT); //led rojo
};

void loop() {
// en la variable distancia guardamos la distancia en centimetros que detecta el sonar
respecto al objetivo
distancia = sonar.ping_cm();
if (distancia < 60){
pausa = distancia * 80;
//hacemos delay para que detecte correctamente el paso de las personas
delay(pausa);
//agregamos los contadores
cuenta++;
cuenta2++;
cuenta3++;
//si llegamos a 9, encender un led y reiniciar a 0 el display para indicar que son
numeros del 10 en adelante
if (cuenta > 9){
cuenta = 0;
digitalWrite(10, HIGH);
}
//si llegamos a 19, encender un segundo led y reiniciar a 0 el display para indicar
que son numeros del 20 en adelante
if (cuenta2 > 19){
// cuenta = 0;
digitalWrite(9, HIGH);
}
//Para detener el display en 29
if (cuenta3 > 29){
cuenta = 9;
}
}

actualizarNumero(); //desplegamos la cuenta en el display

}

Resultados
El resultado final de esta práctica es que el sensor al detectar un movimiento delante de si,
envía una señal de que una persona paso delante de él y el display aumenta en 1 el número
que muestra en pantalla. Debido a que los pines del Arduino solo permiten conectar un display
(aunque con el uso de otros dispositivos se pueden agregar más) cuando la décima persona
se detecte, uno de los LEDs encenderá y el display comenzara en 0 de nuevo, esto pasara de
nuevo cuando se detecte a la persona 20 donde el otro LED encenderá y el display volverá en
0. Con el armado elaborado cuando la persona 29 entre se dejara de contar las personas que
entren.

Practica 08 – Uso del Sensor HC-SR04

9 respuestas

Objetivo:
Aprender el funcionamiento del sensor HC-SR04. Y usarlo para detectar qué tan lejos o cerca
se encuentra un objeto.

Material necesario:
1 – Tarjeta ARDUINO UNO
1 – Cable USB para Arduino
1 – Tarjeta Protoboard
1 – Software IDE de Arduino
1 – Sensor HC – SR04
1 – LED común de cualquier color
1 – resistencia de 220 ó 330 ohms
1 – zumbador o speaker para 5v
Cables

Descripción

1. Conectamos el sensor HC-SR04 a nuestra protoboard.

2. El sensor trae marcado el nombre de los 4 pines con los que cuenta, realizamos la
conexión de la siguiente forma.
1. El pin GND lo conectamos a la tierra.
2. El pin Vcc lo conectamos a corriente.
3. El pin trig lo conectamos al pin 4 digital de Arduino.
4. El pin Echo lo conectamos al pin 5 digital de Arduino.
3. Conectamos un LED a nuestra protoboard, el extremo plano lo conectamos a tierra
mediante una resistencia de 220 ohm o 330 ohm, y el extremo redondo lo conectamos
al pin 8 de Arduino.
4. Conectamos el zumbador a la protoboard, el cable negro lo conectamos a tierra y el
otro lo conectamos al pin 5 de nuestro Arduino.
5. Conectamos los cables de tierra y corriente del Arduino a la protoboard.
6. Cargamos el código.
Diagrama de conexión de la práctica realizado en Fritzing

Código

/*Practica 8 - Uso del Sensor ultrasonico*/

// Se importa la libreria NewPing
#include <NewPing.h>

const int trig = 4; //Pin trig en pin 4

const int echo = 3; //Pin Echo en pin 3
const int zumbador = 5; //zumbador en pin 5
const int led = 8; //LED en pin 8

int distancia; //Guardamos la distancia que detecte el sensor

int pausa; //Guarda el tiempo de espera entre parpadeo

// Se crea un objeto con la libreria NewPing llamado sonar

NewPing sonar(trig, echo, 200); // Each sensor's trigger pin, echo pin, and max
distance to ping.

void setup(){
 pinMode(zumbador,OUTPUT); //Declaramos el zumbador como salida
pinMode(led, OUTPUT); //Declaramos el LED como salida
}

void loop(){

// en la variable distancia guardamos la distancia en centimetros que detecta el sonar

respecto al objetivo
distancia = sonar.ping_cm();

if (distancia < 100){ //restringir el alcance a 1m (100cm)

pausa = distancia * 10; //guardamos el tiempo de pausa
digitalWrite(zumbador, HIGH); //encendemos el zumbador
digitalWrite(led,HIGH); //Encendemos el LED
delay(pausa); //Agregamos un delay que sea igual al tiempo de pausa
}

digitalWrite(zumbador, LOW); //apagamos el zumbador

digitalWrite(led, LOW); //apagamos el LED
delay(pausa); // esperamos el tiempo de pausa
}

Resultados
El resultado de esta práctica es que al posicionar un objeto en el rango del sensor, el speaker
emite un sonido y el LED comienza a parpadear, y entre más cerca se este del sensor el ruido
y el parpadeo serán más rápidos.