Medidor de Distancia Con Arduino

UNIVERSIDAD NACIONAL DE SAN AGUSTIN DE AREQUIPA
UNIVERSIDAD NACIONAL DE SAN AGUSTIN DE

AREQUIPA
FACULTAD DE INGENIERIA PRODUCCION Y SERVICIOS
ESCUELA PROFESIONAL DE INGENIERIA ELECTRICA
LAB. DE REDES DE AUTOMATIZACION Y CONTROL

TEMA: “MEDIDOR DE DISTANCIA CON EL MODULO ARDUINO”
2
INDICE
1. OBJETIVOS GENERALES: .......................................................................................................... 3
2. OBJETIVOS ESPECIFICOS:......................................................................................................... 3
3. MARCO TEORICO:....................................................................................................................... 4
3.1. VISIÓN DE CONJUNTO ............................................................................................................ 4
3.2. ESQUEMA Y DISEÑO DE REFERENCIA ........................................................................... 4
3.3. RESUMEN............................................................................................................................... 6
3.4. PODER..................................................................................................................................... 6
3.5. MEMORIA .............................................................................................................................. 7
3.6. ENTRADA Y SALIDA ........................................................................................................... 7
3.7. COMUNICACIÓN .................................................................................................................. 9
3.8. PROGRAMACIÓN ................................................................................................................. 9
3.9. RESTABLECIMIENTO AUTOMÁTICO (SOFTWARE) ................................................... 10
3.10. PROTECCIÓN DE SOBREINTENSIDAD USB................................................................ 11
3.11. SENSOR ULTRASONICO ................................................................................................. 11
3.11.1. CALCULO DE LA DISTANCIA ..................................................................................... 11
4. MATERIALES: ........................................................................................................................ 12
5. DIAGRAMA DE CONEXIÓN..................................................................................................... 14
6. PROCEDIMIENTO: ..................................................................................................................... 14
7. ALGORITMO DEL ARDUINO................................................................................................... 16
Estructura De Un Programa......................................................................................................... 17
Setup() ........................................................................................................................................... 17
Loop() ............................................................................................................................................ 18
Funciones ...................................................................................................................................... 18
{} Entre Llaves .............................................................................................................................. 19
; Punto y Coma.............................................................................................................................. 19
/*… */ Bloque de Comentarios ..................................................................................................... 20
// Línea de Comentarios ................................................................................................................ 20
9. BIBLIOGRAFIA........................................................................................................................... 26
3
INTRODUCCION
El proyecto Arduino, de origen italiano, pertenece a un movimiento denominado hardware

de código abierto, en el cual sus participantes plantean que así como existe el software
libre, el cual es compartido a nivel de código fuente para poder ser modificado, deberían
existir también plataformas de hardware con la misma filosofía, donde se comparten los
detalles de los diagramas de circuito para que los usuarios puedan introducir sus propias
modificaciones. La plataforma Arduino es lo que se conoce como un entrenador de
microcontrolador (pequeñas computadoras contenidas en un solo circuito integrado), para
la cual hace uso de herramientas de software en PC para su programación.
En este proyecto vamos a incurrir en una aplicación de las varias que tiene el Arduino,
como es el “MEDIDOR DE DISTANCIA CON MODULO ARDUINO”. Este proyecto
usara como material principal un ARDUINO MEGA y el SENSOR ULTRASONICO,
como detector de objetos.
1. OBJETIVOS GENERALES:
 Hacer uso de los protocolos de comunicaciones mediante la programación.
 Desarrollar un proyecto aplicado al curso que sea de utilidad para el uso de las
personas
2. OBJETIVOS ESPECIFICOS:
 Conocer la plataforma de hardware libre Arduino
 Desarrollar aplicaciones mediante sketches
 Conectar el Arduino a la PC mediante la interfase USB y comunicarlos serialmente
 Utilizar la terminal serie para comunicarse con el dispositivo
4
3. MARCO TEORICO:
3.1. VISIÓN DE CONJUNTO
FIGURA NRO 01: Arduino MEGA
Arduino Mega es una placa de microcontrolador basada en ATmega1280. Tiene 54

pines digitales de entrada / salida (de los cuales 14 se pueden usar como salidas PWM),
16 entradas analógicas, 4 UART (puertos serie de hardware), un oscilador de cristal
de 16 MHz , una conexión USB, un conector de alimentación, un encabezado ICSP,
y un botón de reinicio. Contiene todo lo necesario para soportar el
microcontrolador; simplemente conéctelo a una computadora con un cable USB o con
un adaptador de CA a CC o batería para comenzar. El Mega es compatible con la
mayoría de los escudos diseñados para el Arduino Duemilanove o Diecimila.
3.2. ESQUEMA Y DISEÑO DE REFERENCIA
Esquema:
5
FIGURA NR02: Esquema del Arduino MEGA
6
3.3. RESUMEN
Microcontrolador ATmega1280
Tensión de funcionamiento 5V
Voltaje de entrada 7-12V
(recomendado)
Voltaje de entrada (límites) 6-20V
Pines de E / S digitales 54 (de los cuales 15 proporcionan salida de PWM)
Clavijas de entrada analógica dieciséis
Corriente DC por Pin E / S 40 Ma
Corriente DC para 3.3V Pin 50 Ma
Memoria flash 128 KB de los cuales 4 KB utilizados por el gestor de
arranque
SRAM 8 KB
EEPROM 4 KB
Velocidad de reloj 16 MHz
3.4. PODER
El Arduino Mega puede alimentarse a través de la conexión USB o con una fuente de
alimentación externa. La fuente de poder se selecciona automáticamente.
La alimentación externa (no USB) puede provenir de un adaptador de CA a CC (wall-

wart) o batería. El adaptador se puede conectar al enchufar un conector positivo de
2.1 mm en el conector de alimentación de la placa. Los cables de una batería se
pueden insertar en los conectores Gnd y Vin pin del conector POWER.
La placa puede operar con un suministro externo de 6 a 20 voltios. Sin embargo, si se

suministra con menos de 7 V, el pin de 5 V puede suministrar menos de cinco voltios
y la placa puede ser inestable. Si usa más de 12 V, el regulador de voltaje puede
sobrecalentarse y dañar la placa. El rango recomendado es de 7 a 12 voltios.
7
Los pines de alimentación son los siguientes:
 VIN. El voltaje de entrada a la placa Arduino cuando está usando una fuente
de alimentación externa (a diferencia de 5 voltios de la conexión USB u otra
fuente de alimentación regulada). Puede suministrar voltaje a través de este
pin o, si suministra voltaje a través del conector de alimentación, acceda a
través de este pin.
 5V. La fuente de alimentación regulada utilizada para alimentar el
microcontrolador y otros componentes en el tablero. Esto puede provenir de
VIN a través de un regulador de a bordo, o puede ser suministrado por USB
u otro suministro regulado de 5V.
 3V3. Un suministro de 3.3 voltios generado por el chip FTDI a bordo. El
consumo máximo de corriente es de 50 mA.
 GND. Pines de tierra
3.5. MEMORIA
El ATmega1280 tiene 128 KB de memoria flash para almacenar el código (de los
cuales 4 KB se utilizan para el gestor de arranque), 8 KB de SRAM y 4 KB de
EEPROM (que se pueden leer y escribir con la biblioteca EEPROM ).
3.6. ENTRADA Y SALIDA
Cada uno de los 54 pines digitales del Mega se puede usar como entrada o salida, usando
las funciones pinMode () , digitalWrite () y digitalRead () . Operan a 5 voltios.
Cada pin puede proporcionar o recibir un máximo de 40 mA y tiene una resistencia
interna de pull-up (desconectada por defecto) de 20-50 kOhms. Además, algunos
pines tienen funciones especializadas:
 Serie: 0 (RX) y 1 (TX); Serial 1: 19 (RX) y 18 (TX); Serial 2: 17 (RX) y 16

(TX); Serie 3: 15 (RX) y 14 (TX). Se usa para recibir (RX) y transmitir (TX)
datos en serie TTL. Los pines 0 y 1 también están conectados a los pines
correspondientes del chip serie FTDI USB a TTL.
8
 Interrupciones externas: 2 (interrupción 0), 3 (interrupción 1), 18 (interrupción

5), 19 (interrupción 4), 20 (interrupción 3) y 21 (interrupción 2). Estos pines se
pueden configurar para activar una interrupción en un valor bajo, un flanco
ascendente o descendente, o un cambio en el valor. Vea la
función attachInterrupt () para más detalles.
 PWM: 2 a 13 y 44 a 46. Proporcionan salida PWM de 8 bits con la
función analogWrite () .
 SPI: 50 (MISO), 51 (MOSI), 52 (SCK), 53 (SS). Estos pines admiten la
comunicación SPI, que, aunque proporcionada por el hardware subyacente, no
se incluye actualmente en el lenguaje Arduino. Los pines SPI también se
dividen en el encabezado ICSP, que es físicamente compatible con
Duemilanove y Diecimila.
 LED: 13. Hay un LED integrado conectado al pin digital 13. Cuando el pin
tiene un valor ALTO, el LED está encendido, cuando el pin está BAJO, está
apagado.
 I 2 C: 20 (SDA) y 21 (SCL). Admite la comunicación I 2 C (TWI) utilizando
la biblioteca Wire (documentación en el sitio web de Wiring). Tenga en cuenta
que estos pines no se encuentran en la misma ubicación que los pines I 2 C en
Duemilanove o Diecimila.
El Mega tiene 16 entradas analógicas, cada una de las cuales proporciona 10 bits de
resolución (es decir, 1024 valores diferentes). Por defecto, miden desde tierra a 5
voltios, aunque es posible cambiar el extremo superior de su rango usando el pin AREF
y la función analogReference ().
Hay un par de otros pines en el tablero:
 AREF. Voltaje de referencia para las entradas analógicas. Usado

con analogReference ().
 Reiniciar. Traiga esta línea BAJA para reiniciar el
microcontrolador. Normalmente se usa para agregar un botón de reinicio a los
escudos que bloquean el que está en el tablero.
9
3.7. COMUNICACIÓN
El Arduino Mega tiene una serie de instalaciones para comunicarse con una
computadora, otro Arduino u otros microcontroladores. El ATmega1280 proporciona
cuatro UART de hardware para comunicación serial TTL (5V). Un
FTDI FT232RL en la placa canaliza uno de estos por USB y los controladores
FTDI (incluidos con el software Arduino) proporcionan un puerto virtual para el
software en la computadora. El software Arduino incluye un monitor serie que
permite el envío de datos textuales simples hacia y desde la placa
Arduino. Los LED RX y TX de la placa parpadearán cuando los datos se transmitan a
través del chip FTDI y la conexión USB a la computadora (pero no para la
comunicación serial en los pines 0 y 1).
Una biblioteca de SoftwareSerial permite la comunicación serial en cualquiera de los

pines digitales de Mega.
El ATmega1280 también soporta I2C (TWI) y la comunicación SPI. El software

Arduino incluye una biblioteca Wire para simplificar el uso del bus I2C ; vea
la documentación en el sitio web de Wiring para más detalles. Para usar la
comunicación SPI, consulte la hoja de datos ATmega1280 .
3.8. PROGRAMACIÓN
Arduino Mega se puede programar con el software Arduino ( descargar ). Para más
detalles, consulte la referencia y tutoriales .
El ATmega1280 en el Arduino Mega viene pregrabado con un gestor de arranque que

le permite cargar un nuevo código sin el uso de un programador de hardware
externo. Se comunica utilizando el protocolo original STK500 ( referencia , archivos
de encabezado C ).
10
También puede omitir el gestor de arranque y programar el microcontrolador a través

del encabezado ICSP (Programación serial en circuito); ver estas instrucciones para
más detalles.
3.9. RESTABLECIMIENTO AUTOMÁTICO (SOFTWARE)
En lugar de requerir una pulsación física del botón de reinicio antes de una carga, el
Arduino Mega está diseñado de manera que permite su reinicio mediante un software
que se ejecuta en una computadora conectada. Una de las líneas de control de flujo de
hardware (DTR) del FT232RL está conectada a la línea de reinicio del ATmega1280
a través de un condensador de 100 nanofaradios. Cuando esta línea se afirma (se toma
bajo), la línea de reinicio cae lo suficiente como para restablecer el chip. El software
Arduino utiliza esta capacidad para permitirle cargar código simplemente
presionando el botón de carga en el entorno Arduino. Esto significa que el gestor de
arranque puede tener un tiempo de espera más corto, ya que la disminución de DTR
se puede coordinar bien con el inicio de la carga.
Esta configuración tiene otras implicaciones. Cuando Mega está conectada a una
computadora con Mac OS X o Linux, se restablece cada vez que se realiza una conexión
desde el software (a través de USB). Durante el siguiente medio segundo más o
menos, el gestor de arranque se está ejecutando en el Mega. Mientras está
programado para ignorar datos mal formados (es decir, cualquier cosa además de una
carga de código nuevo), interceptará los primeros bytes de datos enviados a la placa
después de que se abra una conexión. Si un boceto que se ejecuta en la placa recibe
una configuración de una sola vez u otros datos cuando se inicia por primera vez,
asegúrese de que el software con el que se comunica espera un segundo después de
abrir la conexión y antes de enviar esta información.
El Mega contiene un rastro que se puede cortar para desactivar el reinicio

automático. Las almohadillas a cada lado de la traza pueden soldarse juntas para
volver a habilitarlo. Está etiquetado como "RESET-EN". También puede desactivar
el restablecimiento automático conectando una resistencia de 110 ohmios desde 5 V a
la línea de reinicio; mira este hilo del foro para más detalles.
11
3.10. PROTECCIÓN DE SOBREINTENSIDAD USB
El Arduino Mega tiene un polifuse reseteable que protege los puertos USB de tu
computadora contra cortos y sobrecorrientes. Aunque la mayoría de las computadoras
proporcionan su propia protección interna, el fusible proporciona una capa adicional
de protección. Si se aplica más de 500 mA al puerto USB, el fusible interrumpirá
automáticamente la conexión hasta que se elimine el cortocircuito o la sobrecarga.
3.11. SENSOR ULTRASONICO

Como su nombre lo indica, los sensores ultrasónicos miden la distancia mediante el uso
de ondas ultrasónicas. El cabezal emite una onda ultrasónica y recibe la onda reflejada
que retorna desde el objeto. Los sensores ultrasónicos miden la distancia al objeto
contando el tiempo entre la emisión y la recepción.
FIGURA NRO 03: Funcionamiento básico del Ultrasonico
Un sensor óptico tiene un transmisor y receptor, mientras que un sensor ultrasónico

utiliza un elemento ultrasónico único, tanto para la emisión como la recepción. En un
sensor ultrasónico de modelo reflectivo, un solo oscilador emite y recibe las ondas
ultrasónicas, alternativamente. Esto permite la miniaturización del cabezal del sensor.
3.11.1. CALCULO DE LA DISTANCIA
La distancia se puede calcular con la siguiente fórmula:
�𝑖��𝑎��𝑐𝑖𝑎 𝐿 = 1/2 × 𝑇 × �
Dónde:
 L es la distancia,
 T es el tiempo entre la emisión y la recepción, y
12
 C es la velocidad del sonido. (El valor se multiplica por 1/2 ya que T es el

tiempo de recorrido de ida y vuelta).
4. MATERIALES:
 Arduino MEGA
 2 Protoboard donde conectaremos los componentes
 Cables para hacer las conexiones
 6 resistencias de 220 Ω
 2 LED verde
 2 LED amarillo
 2 LED rojo
 2 sensor ultrasónico Arduino (HC-SR04)
 1 buzzer
 Pantalla digital de 16 x 2
FIGURA NRO 04: Arduino a usar
13
FIGURA NRO 05: Puerto Serial
FIGURA NRO 06: Ultrasonido
FIGURA NRO 07: LCD
14
5. DIAGRAMA DE CONEXIÓN
FIGURA NRO 07: Diagrama de Conexion
6. PROCEDIMIENTO:
Las resistencias son de 220 Ω y se colocan en serie con los LEDs. El sensor ultrasónico
Arduino se conecta a dos pines digitales, uno para el trigger o disparador y otro para
el echo o receptor. El buzzer Arduino se conecta a una salida PWM.
Lo primero que haré será plantear el algoritmo del sistema de detección de obstáculos.
1. Comprobar la distancia de los objetos

1. ¿Está dentro del rango para avisar?
1. Si
1. Lanzar alarma visual y sonora
2. Continuar
2. No
1. Continuar
El algoritmo del sistema de alerta visual y sonora sería el siguiente.
1. ¿Está en zona verde?
15
1. Si
1. Encender LED verde
2. Emitir sonido 1
3. Salir
2. No
1. Continuar
2. ¿Está en zona amarilla?
1. Si
1. Encender LED amarillo
2. Emitir sonido 2
3. Salir
2. No
1. Continuar
3. ¿Está en zona roja?
1. Si
1. Encender LED rojo
2. Emitir sonido 2
3. Salir
2. No
1. Continuar
*Este procedimiento lo haremos semejante para el otro sensor, independientemente uno del
otro.
El LCD lo configuraremos indicando los Pines correspondientes sobrantes y en el mismo

programa lo correremos en conjunto con los ultrasonidos.
De los dos algoritmos anteriores, deducimos que vamos a necesitar varios umbrales de
decisión, uno para cada situación. Podemos coger una simple regla y determinarlos.
Umbral 1: está en zona verde desde 30 cm a 20 cm.

Umbral 2: está en zona amarilla, desde 20 cm a 10 cm.
Umbral 3: está en zona roja, menos de 10 cm.
FIGURA NRO 08
16
FIGURA NRO 09
FIGURA NRO 10
7. ALGORITMO DEL ARDUINO
Desarrollado en el programa propio del Arduino, que es descargable, a continuación

mostraremos las prinicaples caracteres del programa:
Un programa de Arduino (conocido en inglés como sketch), usa primordialmente la sintaxis

de C/C++ para definir todas las operaciones que llevara a cabo el microcontrolador.
17
Estructura De Un Programa
La estructura básica del lenguaje de programación de Arduino es bastante simple y se

compone de al menos dos partes. Estas dos partes necesarias, o funciones, encierran
bloques que contienen declaraciones, estamentos o instrucciones.
void setup() //Primera Parte

{
estamentos;
}
void loop() //Segunda Parte
{
estamentos;
}
En donde setup() es la parte encargada de recoger la configuración y loop() es la que

contiene el programa que se ejecutará cíclicamente (de ahí el término loop –bucle-). Ambas
funciones son necesarias para que el programa trabaje.
La función de configuración (setup) debe contener la declaración de las variables. Es la

primera función a ejecutar en el programa, se ejecuta sólo una vez, y se utiliza para
configurar o inicializar pinMode (modo de trabajo de las E/S), configuración de la
comunicación en serie y otras.
La función bucle (loop) siguiente contiene el código que se ejecutara continuamente

(lectura de entradas, activación de salidas, etc) Esta función es el núcleo de todos los
programas de Arduino y la que realiza la mayor parte del trabajo.
Setup()
La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para
inicializar los modos de trabajo de los pins, o el puerto serie. Debe ser incluido en un
programa aunque no haya declaración que ejecutar. Así mismo se puede utilizar para
establecer el estado inicial de las salidas de la placa.
void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
digitalWrite(pin, HIGH); // pone el ‘pin’ en estado HIGH
}
18
Loop()
Después de llamar a setup(), la función loop() hace precisamente lo que sugiere su nombre,
se ejecuta de forma cíclica, lo que posibilita que el programa esté respondiendo
continuamente ante los eventos que se produzcan en la placa.
void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) el 'pin'
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el 'pin'
delay(1000);
}
Funciones
Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones

que son ejecutadas cuando se llama a la función. Son funciones setup() y loop() de las que
ya se ha hablado. Las funciones de usuario pueden ser escritas para realizar tareas
repetitivas y para reducir el tamaño de un programa. Las funciones se declaran asociadas a
un tipo de valor “type”. Este valor será el que devolverá la función, por ejemplo 'int' se
utilizará cuando la función devuelve un dato numérico de tipo entero. Si la función no
devuelve ningún valor entonces se colocará delante la palabra “void”, que significa
“función vacía”. Después de declarar el tipo de dato que devuelve la función se debe
escribir el nombre de la función y entre paréntesis se escribirán, si es necesario, los
parámetros que se deben pasar a la función para que se ejecute.
type nombreFunción(parámetros)
{
instrucción;
}
La función siguiente devuelve un número entero, delayVal() se utiliza para poner un valor
de retraso en un programa que lee una variable analógica de un potenciómetro conectado a
una entrada de Arduino. Al principio se declara como una variable local, 'v' recoge el valor
leído del potenciómetro que estará comprendido entre 0 y 1023, luego se divide el valor por
4 para ajustarlo a un margen comprendido entre 0 y 255, finalmente se devuelve el valor 'v'
y se retornaría al programa principal. Esta función cuando se ejecuta devuelve el valor de tipo
entero 'v'.
19
int delayVal()
{
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potenciómetro
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}
{} Entre Llaves
Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se

utilizan para los bloques de programación setup(), loop(), if.., etc.
type funcion()
{
instrucciones;
}
Una llave de apertura “{“ siempre debe ir seguida de una llave de cierre “}”, si no es así el
programa dará errores.
El entorno de programación de Arduino incluye una herramienta de gran utilidad para

comprobar el total de llaves. Sólo tienes que hacer click en el punto de inserción de una
llave abierta e inmediatamente se marca el correspondiente cierre de ese bloque (llave
cerrada).
; Punto y Coma
El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de programación de

Arduino. También se utiliza para separar elementos en una instrucción de tipo “bucle for”.
int x = 13; /* declara la variable 'x' como tipo entero de

valor 13 */
Nota: Olvidaos de poner fin a una línea con un punto y coma o se producirá en un error de
compilación. El texto de error puede ser obvio, y se referirá a la falta de una coma, o puede
que no. Si se produce un error raro y de difícil detección lo primero que debemos hacer es
comprobar que los puntos y comas están colocados al final de las instrucciones.
20
/*… */ Bloque de Comentarios
Los bloques de comentarios, o comentarios multi-línea son áreas de texto ignorados por el
programa que se utilizan para las descripciones del código o comentarios que ayudan a
comprender el programa. Comienzan con / * y terminan con * / y pueden abarcar varias
líneas.
/* esto es un bloque de comentario no se debe olvidar

cerrar los comentarios estos deben estar equilibrados */
Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la
memoria de Arduino pueden ser utilizados con generosidad. También pueden utilizarse
para "comentar" bloques de código con el propósito de anotar informaciones para depuración
y hacerlo mas comprensible para cualquiera.
Nota: Dentro de una misma línea de un bloque de comentarios NO se puede escribir otro
bloque de comentarios (usando /*..*/).
// Línea de Comentarios
Una línea de comentario empieza con // y terminan con la siguiente línea de código. Al
igual que los comentarios de bloque, los de línea son ignoradas por el programa y no
ocupan espacio en la memoria.
// esto es un comentario
Una línea de comentario se utiliza a menudo después de una instrucción, para proporcionar
más información acerca de lo que hace ésta o para recordarla más adelante.
21
PROGRAMA ARDUINO
Programa de MEDIDOR DE DISTANCIA CON MODULO ARDUINO
//#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Ultrasonic.h>
Ultrasonic ultrasonic(6,5,5800); // (Trig PIN,Echo PIN)
Ultrasonic ultrasonic2(9,4,5800); // (Trig PIN,Echo PIN)
//Luego sustituye los 3000 microsegundos con el tiempo maximo de
tiempo que necesitemos.
//La formula a utilizar es: centimetros * 58 = Max.Tiempo de
salida
LiquidCrystal_I2C lcd(0x27,16,3);
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&& const
int EchoPin = 5; const int
TriggerPin = 6; const int
EchoPin2 = 4; const int
TriggerPin2 = 9;
const int LedPinVerde = 13;
const int LedPinAmarillo = 12;
const int LedPinRojo = 11;
const int LedPinAzul = 7;
const int LedPinAnaranjado = 8;
22
const int LedPinRojo2 = 10;

float distancia;
float distancia2;
long tiempo;
long tiempo2;
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
void setup()
{
lcd.init(); // inicializando el lcd
// Print a message to the LCD.
lcd.backlight();
//lcd.begin(0,0);
lcd.print(" GRUPAZO 18 RAC");
delay(1700);
lcd.print("MEDIDOR DE DISTANCIA");
delay(2000);
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
Serial.begin(9600);
pinMode(LedPinVerde, OUTPUT);
pinMode(LedPinAmarillo, OUTPUT);
pinMode(LedPinRojo, OUTPUT);
pinMode(LedPinAzul, OUTPUT);
pinMode(LedPinAnaranjado, OUTPUT);
pinMode(LedPinRojo2, OUTPUT);
pinMode(TriggerPin, OUTPUT);
pinMode(EchoPin, INPUT);
pinMode(TriggerPin2, OUTPUT);
pinMode(EchoPin2, INPUT);
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
}
void loop()
{
lcd.clear();
lcd.setCursor(0,0);
lcd.print("SENSOR #01=");
lcd.setCursor(11,0);
lcd.print(ultrasonic.Ranging(CM)); // CM or INC
lcd.print("cm");
lcd.setCursor(0,1);
lcd.print("SENSOR #02=");
lcd.setCursor(11,1);
lcd.print(ultrasonic2.Ranging(CM)); // CM or INC
lcd.print("cm");
delay(500);
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
23
digitalWrite(TriggerPin, HIGH); //pulso para activar el sensor 1

delayMicroseconds(10);
digitalWrite(TriggerPin, LOW);
tiempo = (pulseIn(EchoPin, HIGH) / 2);
digitalWrite(TriggerPin2, HIGH); // pulso para activar el sensor
2
delayMicroseconds(10);
digitalWrite(TriggerPin2, LOW);
tiempo2 = (pulseIn(EchoPin2, HIGH) / 2); distancia =
float(tiempo * 0.0343); Serial.print("Distancia: "); //
imprime la distancia en el
Monitor Serie
Serial.println(distancia);
if (distancia >= 50) {
digitalWrite(LedPinVerde , HIGH);
digitalWrite(LedPinAmarillo , LOW);
digitalWrite(LedPinRojo , LOW);
}
else if ((distancia < 50) && (distancia >= 20)) {
digitalWrite(LedPinVerde , LOW);
digitalWrite(LedPinRojo , LOW);
digitalWrite(LedPinAmarillo , HIGH);
}
else if (distancia < 20) {
digitalWrite(LedPinVerde , LOW);
digitalWrite(LedPinAmarillo , LOW);
digitalWrite(LedPinRojo , HIGH);
}
distancia2 = float(tiempo2 * 0.0343);
Serial.print("Distancia: "); // imprime la distancia en el
Monitor Serie 2
Serial.println(distancia2);
if (distancia2 > 50) {
digitalWrite(LedPinAzul , HIGH);
digitalWrite(LedPinAnaranjado , LOW);
digitalWrite(LedPinRojo2 , LOW);
}
else if ((distancia2 < 49) && (distancia2 >= 20)) {
digitalWrite(LedPinAzul , LOW);
digitalWrite(LedPinRojo2 , LOW);
digitalWrite(LedPinAnaranjado , HIGH);
}
else if (distancia2 < 19) {
digitalWrite(LedPinAzul , LOW);
digitalWrite(LedPinAnaranjado , LOW);
digitalWrite(LedPinRojo2 , HIGH);
}
delay(1000);
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
}
24
FIGURA NRO: 11
FIGURA NRO: 12
25
FIGURA NRO: 13
FIGURA NRO: 14
26
8. CONCLUSIONES Y OBSERVACIONES
CONCLUSIONES:
 El Arduino como herramienta de microcontrolador, no es practico para proyectos de

menor escala y algunos de mayor escala.
OBSERVACIONES
 Habra que tener mucho cuidado con los objetos que su utilizaran ya que hay
materiales, que absorben el sonido emitido por el Ultrasonico, como es el caso del
algodón, que lo que hace es absorverlo y no revotarlo.
 Si deseamos introducir mas funciones, neceistaremos mas pines de entrada, para
este caso será necesario adaptar puertos como lo que se hizo con el LCD
 La programación, tiene que llevar un cierto grado de pasos a seguir, conociendo
bien los bucles que se utilizaran
 Tener el cuidado de escoger el Arduino correcto.
9. BIBLIOGRAFIA
 http://www.arduino.cc
 http://arduino.cc/en/Reference/HomePage
REFERENCIA EN LÍNEA DEL LENGUAJE
 MASSIMO BANZI, “GETTING STARTED WITH ARDUINO” O'REILLY MEDIA /

MAKE PUBLISHER, MARZO 2009, ISBN: 978-0-596-15551-3
 http://www.udb.edu.sv
INTRODUCCIÓN A LA PLATAFORMA ARDUINO
27
27

Medidor de Distancia Con Arduino

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Medidor de Distancia Con Arduino

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSIDAD NACIONAL DE SAN AGUSTIN DE AREQUIPA

UNIVERSIDAD NACIONAL DE SAN AGUSTIN DE

ESCUELA PROFESIONAL DE INGENIERIA ELECTRICA

LAB. DE REDES DE AUTOMATIZACION Y CONTROL

El proyecto Arduino, de origen italiano, pertenece a un movimiento denominado hardware

 Hacer uso de los protocolos de comunicaciones mediante la programación.

 Conocer la plataforma de hardware libre Arduino

 Desarrollar aplicaciones mediante sketches

 Conectar el Arduino a la PC mediante la interfase USB y comunicarlos serialmente

 Utilizar la terminal serie para comunicarse con el dispositivo

3.1. VISIÓN DE CONJUNTO

FIGURA NRO 01: Arduino MEGA

Arduino Mega es una placa de microcontrolador basada en ATmega1280. Tiene 54

3.2. ESQUEMA Y DISEÑO DE REFERENCIA

FIGURA NR02: Esquema del Arduino MEGA

La alimentación externa (no USB) puede provenir de un adaptador de CA a CC (wall-

La placa puede operar con un suministro externo de 6 a 20 voltios. Sin embargo, si se

Los pines de alimentación son los siguientes:

3.6. ENTRADA Y SALIDA

 Serie: 0 (RX) y 1 (TX); Serial 1: 19 (RX) y 18 (TX); Serial 2: 17 (RX) y 16

 Interrupciones externas: 2 (interrupción 0), 3 (interrupción 1), 18 (interrupción

Hay un par de otros pines en el tablero:

 AREF. Voltaje de referencia para las entradas analógicas. Usado

Una biblioteca de SoftwareSerial permite la comunicación serial en cualquiera de los

El ATmega1280 también soporta I2C (TWI) y la comunicación SPI. El software

El ATmega1280 en el Arduino Mega viene pregrabado con un gestor de arranque que

También puede omitir el gestor de arranque y programar el microcontrolador a través

3.9. RESTABLECIMIENTO AUTOMÁTICO (SOFTWARE)

El Mega contiene un rastro que se puede cortar para desactivar el reinicio

3.10. PROTECCIÓN DE SOBREINTENSIDAD USB

3.11. SENSOR ULTRASONICO

FIGURA NRO 03: Funcionamiento básico del Ultrasonico

Un sensor óptico tiene un transmisor y receptor, mientras que un sensor ultrasónico

3.11.1. CALCULO DE LA DISTANCIA

La distancia se puede calcular con la siguiente fórmula:

 C es la velocidad del sonido. (El valor se multiplica por 1/2 ya que T es el

FIGURA NRO 04: Arduino a usar

FIGURA NRO 05: Puerto Serial

FIGURA NRO 06: Ultrasonido

FIGURA NRO 07: LCD

FIGURA NRO 07: Diagrama de Conexion

1. Comprobar la distancia de los objetos

El algoritmo del sistema de alerta visual y sonora sería el siguiente.

1. ¿Está en zona verde?

El LCD lo configuraremos indicando los Pines correspondientes sobrantes y en el mismo

Umbral 1: está en zona verde desde 30 cm a 20 cm.

7. ALGORITMO DEL ARDUINO

Desarrollado en el programa propio del Arduino, que es descargable, a continuación

Un programa de Arduino (conocido en inglés como sketch), usa primordialmente la sintaxis

La estructura básica del lenguaje de programación de Arduino es bastante simple y se

void setup() //Primera Parte

En donde setup() es la parte encargada de recoger la configuración y loop() es la que

La función de configuración (setup) debe contener la declaración de las variables. Es la

La función bucle (loop) siguiente contiene el código que se ejecutara continuamente

Una función es un bloque de código que tiene un nombre y un conjunto de instrucciones

Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se

El entorno de programación de Arduino incluye una herramienta de gran utilidad para

El punto y coma “;” se utiliza para separar instrucciones en el lenguaje de programación de

int x = 13; /* declara la variable 'x' como tipo entero de

/*… */ Bloque de Comentarios

/* esto es un bloque de comentario no se debe olvidar

Programa de MEDIDOR DE DISTANCIA CON MODULO ARDUINO

const int LedPinRojo2 = 10;

digitalWrite(TriggerPin, HIGH); //pulso para activar el sensor 1

/… / Bloque de Comentarios