UNIVERSIDAD DE GUAYAQUIL

CARRERA DE INGENIERÍA EN NETWORKING

Y TELECOMUNICACIONES

CICLO V

TEMA:
RADAR 360 CON ARDUINO

INTEGRANTES:

 ARTURO ASITIMBAY FRANCISCO ANDRES

 CHAVEZ BORJA KATLEEN ANDREINA
 LARA PATIÑO MAURICIO MICHELLE
 PIN SOLEDISPA KENIA LILIBETH

DOCENTE:
ING. XIMENA ACARO

PARALELO:
5-1

FECHA:
21/DIC/2018

GUAYAQUIL – ECUADOR
2018-2019
 1. INDICE
2. INTRODUCCION
3. OBJETIVOS
4. MARCO TEÓRICO
ARDUINO LEONARDO

El Arduino Leonardo es un tablero de microcontroladores basado en el ATmega32U4.

Tiene 23 pines de entrada / salida digital (de los cuales 7 se pueden usar como salidas
PWM y 12 como entradas analógicas), un cristal de 16 MHz, una conexión USB, un
conector de alimentación, y una programación del sistema en circuito (ICSP) encabezado, y
un botón de reinicio. Contiene todo lo necesario para soportar el microcontrolador;
simplemente conéctelo a una computadora (o al adaptador de corriente de pared apropiado)
con un cable Micro USB o enciéndalo con un adaptador de CA a CC o una batería para
comenzar (el cable USB y la fuente de alimentación no están incluidos). Esta placa se envía
con el conector de alimentación y los cabezales de orificio pasante soldados, como se
muestra en la imagen del producto.
Leonardo difiere de todas las placas Arduino anteriores en que el microcontrolador AVR
ATmega32U4 programable por el usuario tiene funcionalidad USB incorporada, lo que
elimina la necesidad de un procesador secundario. Esto hace que el Leonardo sea más
versátil: además de admitir una interfaz de puerto serie / COM virtual (CDC), puede
aparecer en una computadora conectada como un mouse y un teclado. Consulte la página
de inicio de Arduino para ver más implicaciones del diseño de MCU de Leonardo.

Arduino tiene una gran comunidad de soporte y un extenso conjunto de bibliotecas de

soporte y "escudos" de hardware (por ejemplo, puede hacer que su Arduino sea inalámbrico
con nuestro escudo Wixel), lo que lo convierte en una excelente plataforma de introducción
para dispositivos electrónicos integrados. Tenga en cuenta que también ofrecemos un kit
para inventores SparkFun, que incluye un Arduino Uno junto con una variedad de
componentes (por ejemplo, una placa de pruebas, sensores, cables de puente y LED) que
hacen posible crear una serie de proyectos introductorios divertidos.

CARACTERÍSTICAS:

 Microcontrolador Atmega32u4.
 Voltaje de entrada: 7-12V.
 Voltaje de trabajo: 5V.
 Corriente por pin I/O: 40mA.
 20 pines digitales I/O.
 7 canales PWM.
 12 ADC.
 16MHz de velocidad de reloj.
 Memoria Flash: 32 KB (ATmega32u4) de los cuales 4 KB son usador por el
bootloader.
 Memoria SRAM: 2.5 KB (ATmega32u4).
 Memoria EEPROM: 1KB (ATmega32u4).
 Dimensiones: 68.6 x 53.3mm.

ALIMENTACIÓN
La placa Arduino Leonardo, puede ser alimentada a través de la conexión micro USB o con
una fuente de alimentación externa. La fuente de alimentación se selecciona
automáticamente.
Para usar alimentación externa (no mediante USB), ésta puede venir de un adaptador de CA
a CC o de una batería. El adaptador (transformador), lo podemos conectar mediante un
jack de 2.1mm con centro positivo a la toma de alimentación de la placa. Sin embargo, los
cables de los que disponga nuestra batería, los podemos insertar en los pines GND y Vin de
la placa.

La placa puede operar mediante una alimentación externa de 6 a 20 Voltios. En caso de

alimentar la placa con menos de 7Voltios, el pin de 5Voltios puede no llegar a este valor y
la placa podría volverse inestable. Sin embargo, si utilizamos más de 12Voltios, el
regulador de tensión puede sobrecalentarse y llegar a dañar nuestra placa. Por lo tanto, el
rango recomendado de alimentación es de 7 a 12 Voltios.

Los pines de alimentación son los siguientes:

 VIN. El voltaje de entrada a la placa Arduino cuando se utiliza una fuente de
alimentación externa (a diferencia de 5 Voltios de la conexión USB o de otra fuente
de alimentación regulada). Se puede suministrar tensión a través de este pin, o, si el
suministro de tensión se realiza a través del transformador, podremos acceder a
través de este pin.
 5V. Fuente de alimentación regulada usada para alimentar el microcontrolador y
otros componentes en la placa.
 3V3. Un suministro de 3.3 Voltios, generados por el integrado. Consumo de
corriente máxima: 50 mA.
 GND. Pines de masa (0 Voltios).
 IOREF. Tensión a la cual los pines de entrada y salida están funcionando.

MEMORIA
El ATmega32u4 que incorpora el Arduino Leonardo, posee 32 KB (4 KB utilizados para el
bootloader). También ofrece 2,5 KB de SRAM y 1 KB de EEPROM (los cuales pueden ser
leídos y escritos con la librería EEPROM).

ENTRADAS Y SALIDAS
Cada uno de los 20 pines digitales de entrada/salida que posee la placa, se pueden utilizar
mediante las funciones de siempre: pinMode (), digitalWrite () o digitalRead ().
Cada uno de los 20 pines de E/S digitales se pueden utilizar como entrada o salida, usando
las funciones pinMode (), digitalWrite() y digitalRead(). Cada pin proporcionará un
máximo de 40 mA y, tampoco podrá recibir más de este valor.
  Serial: 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y transmitir (TX) datos serie
TTL con la capacidad de hardware serie del ATmega32U4. Hay que tener en cuenta
que, en Arduino Leonardo, la clase Serial se refiere a la comunicación USB (CDC) ;
para serie TTL en los pines 0 y 1, utilizaremos la clase Serial1.
 IST: 2 (SDA) y 3 (SCL). Soportan la comunicación TWI utilizando la librería
Wire.
 Interrupciones externas: 2 y 3. Estos pines se pueden configurar para
desencadenar una interrupción en un valor bajo, un flanco ascendente o
descendente, o un cambio en el valor. Ver attachInterrupt () para obtener más
detalles.
 PWM: 3, 5, 6, 9, 10, 11 y 13. Proporcionan 8-bit de salida PWM con la función
analogWrite ().
 SPI: en la cabecera de ICSP. Estos pines soportan la comunicación SPI utilizando
la librería SPI. Debemos tener en cuenta que los pines de SPI no está conectados a
cualquiera de los pines digitales de entrada/salida, como están en Arduino UNO.
Sólo están disponibles en el conector ICSP.
 LED: 13. Hay un LED smd conectado al pin digital 13. Cuando el pin tiene valor
alto, el led está encendido, cuando se pasa a valor bajo, se apaga.
 Entradas Analógicas: A0-A5, A6 – A11 (en los pines digitales 4, 6, 8, 9, 10, y 12).
La placa Arduino Leonardo tiene 12 entradas analógicas, las cuales van desde A0
hasta A11. También pueden ser utilizadas como entradas/salidas digitales. Los pines
A0-A5 están situados en el mismo lugar que en Arduino UNO; las entradas A6-A11
se corresponden con las entradas/salidas digitales de los pines 4, 6, 8, 9, 10 y 12,
respectivamente. Cada entrada analógica puede proporcionar 10 bits de resolución,
es decir 1024 valores diferentes (desde 0 hasta 1023). Por defecto, la medida de las
entradas analógicas van desde 0 a 5 Voltios, aunque se puede cambiar el extremo
superior de su rango con el pin AREF y la función analogReference ().
 AREF. Tensión de referencia para las entradas analógicas. Se utiliza con
analogReference ().
 Reset: reinicia el microcontrolador.

COMUNICACIÓN
La placa Arduino Leonardo ofrece importantes facilidades para obtener comunicación con
un ordenador, otro Arduino o incluso con otros microcontroladores. El ATmega32u4
incorpora comunicación serie UART TTL (5Voltios) disponible en los pines digitales 0
(RX) y 1 (TX), los cuales se han comentado anteriormente.
Este microcontrolador también nos permitirá establecer una comunicación serial a través de
USB (CDC) y aparecer como puerto COM virtual con en nuestro sistema operativo. El
integrado también actúa a modo de dispositivo de máxima velocidad USB 2.0, utilizando
los drivers estándar de COM USB. Para Windows, se necesitará un archivo con extensión
.inf.

El IDE de Arduino incluye un monitor de puerto serie que nos va a proporcionar la opción
de transmitir texto desde la placa Arduino y, hacia la misma. Ya sabemos que los LEDs TX
y RX de la placa parpadearán cuando se transmitan datos a través de la conexión USB al
ordenador (pero no para la comunicación de serie en los pines 0 y 1).
Para establecer una comunicación serie en cualquiera de los pines digitales de Arduino,
usaremos la librería SoftwareSerial

El ATmega32u4 también es compatible con la comunicación I2C (TWI) y SPI. El IDE de

Arduino incluye la librería Wire (enlace compartido anteriormente) para simplificar el uso
del bus I2C, puedes consultar la información para obtener más detalles sobre esto. La
librería SPI la utilizaremos para la comunicación SPI. Mediante Arduino Leonardo,
podemos emular un teclado y un ratón genérico, y puede ser programado para controlar
estos dispositivos de entrada utilizando clases Keyboard & Mouse.

PROGRAMACIÓN
La placa Arduino Leonardo se programará con el software de Arduino y, tan sólo
deberemos elegir el modelo de placa que vamos a utilizar.

PROTECCIÓN CONTRA PICOS DE CORRIENTE EN EL USB

La placa Arduino Leonardo posee un polifusible reseteable que protege los puertos USB de
nuestro ordenador de las variaciones de corriente. Aunque, si no todos, la mayoría de los
ordenadores ofrecen una protección interna, el fusible nos proporciona una protección
extra. Si aplicamos más de 500 mA al puerto USB del ordenador, el fusible
automáticamente corta la conexión hasta que el cortocircuito o sobrecarga desaparezca.
SERVOMOTOR SG90

En este artículo te voy a enseñar cómo utilizar un servomotor con Arduino. Antes de
continuar es importante saber qué es un servomotor o servo. Es un motor eléctrico pero con
dos características especiales. Por un lado, nos permite mantener una posición que
indiquemos, siempre que esté dentro del rango de operación del propio dispositivo. Por otro
lado nos permite controlar la velocidad de giro, podemos hacer que antes de que se mueva a
la siguiente posición espere un tiempo.

CARACTERÍSTICAS
Hay varios modelos de servomotor con Arduino. En este caso vamos a utilizar un Micro
Servo 9g SG90 de Tower Pro. Como siempre digo, hay que mirar la ficha técnica del
producto. Todos tienen un funcionamiento muy parecido y la programación puede variar
muy poco.
Cosas a tener en cuenta con este dispositivo. Lo primero, el ángulo de giro, en este caso nos
permite hacer un barrido entre -90º y 90º. Lo que viene a ser un ángulo de giro de 180º.

Aunque el servo puede moverse con una resolución de más de 1 grado, este es el máximo
de resolución que vamos a conseguir debido a la limitación de la señal PWM que es capaz
de generar Arduino UNO.

Estos motores funcionan con una señal PWM, con un pulso de trabajo entre 1 ms y 2 ms y
con un periodo de 20 ms (50 Hz). ¿Qué quiere decir todo esto? Este dato nos indica
la velocidad máxima a la que podemos mover el servomotor con Arduino. Solo podremos
cambiar de posición cada 20 ms. Esto dependerá del tipo y marca de nuestro servo.

CONEXIONADO CON ARDUINO

Las conexiones dependerán del tipo de servomotor con Arduino que estemos utilizando.

Todos deben tener 3 cables. Uno irá a tierra, otro a la alimentación de 5 Voltios y el tercero
a un pin PWM. También puedes utilizar un shield para controlar servomotores, como el de
Adafruit.

Girando grado a grado el servomotor

Vamos a realizar otro ejemplo un poco más complicado, en este caso queremos que el servo
haga un barrido desde el 0 al 180º y luego en sentido contrario. Vamos a utilizar los
mismos métodos pero incorporamos dos bucles for, uno para cada sentido.

// Incluímos la librería para poder controlar el servo

#include <Servo.h>

// Declaramos la variable para controlar el servo

Servo servoMotor;

void setup() {
// Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);

// Iniciamos el servo para que empiece a trabajar con el pin 9

servoMotor.attach(9);

// Inicializamos al ángulo 0 el servomotor

servoMotor.write(0);
}

void loop() {

// Vamos a tener dos bucles uno para mover en sentido positivo y otro en sentido negativo
// Para el sentido positivo
for (int i = 0; i <= 180; i++)
{
// Desplazamos al ángulo correspondiente
servoMotor.write(i);
// Hacemos una pausa de 25ms
delay(25);
}

// Para el sentido negativo

for (int i = 179; i > 0; i--)
{
// Desplazamos al ángulo correspondiente
servoMotor.write(i);
// Hacemos una pausa de 25ms
delay(25);
}
}
https://programarfacil.com/tutoriales/fragmentos/servomotor-con-arduino/

¿Cómo funciona el sensor HC-SR04?

 El sensor HC-SR04 es un módulo que incorpora un par de transductores de ultrasonido que
se utilizan de manera conjunta para determinar la distancia del sensor con un objeto
colocado enfrente de este. Un transductor emite una “ráfaga” de ultrasonido y el otro capta
el rebote de dicha onda. El tiempo que tarda la onda sonora en ir y regresar a un objeto
puede utilizarse para conocer la distancia que existe entre el origen del sonido y el objeto.

En el mercado existen 2 tipos de módulos para medición de distancia por ultrasonido que se
utilizan en robótica y aplicaciones similares:
 Interfaz mediante pulso de eco: Este tipo de sensores poseen un pin de disparo y otro de
eco, algunos incluso combinan ambas funcionalidades en un solo pin. El microcontrolador
que desea realizar una medición debe medir el tiempo en alto de un pulso digital.
 Interfaz serial (I2C o UART): Este tipo de módulos entregan su medición en formato digital
a través de una interfaz serial (I2C o UART). Habitualmente se acceden como si se tratara
de una memoria serial I2C y podemos leer los registros donde se encuentran las mediciones
de distancia.
El HC-SR04 es un sensor que funciona a través de la medición del pulso de echo y
solamente explicaremos este tipo de sensores en este tutorial.
A continuación puedes descargar la hoja de datos del sensor para conocerlo más a fondo.
 Descarga hoja de datos del sensor HC-SR04

¿Cómo se comunica con Arduino el sensor HC-SR04?

La interfaz del sensor HC-SR04 y arduino se logra mediante 2 pines digitales: el pin de
disparo (trigger) y eco (echo). La función de cada uno de estos pines es la siguiente:
 El pin trigger recibe un pulso de habilitación de parte del microcontrolador, mediante el
cual se le indica al módulo que comience a realizar la medición de distancia.
 En el pin echo el sensor devuelve al microcontrolador un puso cuyo ancho es proporcional
al tiempo que tarda el sonido en viajar del transductor al obstáculo y luego de vuelta al
módulo.
Mediante una sencilla formula puede estimarse entonces la distancia entre el sensor y el
obstáculo si se conoce el tiempo de viaje del sonido así como la velocidad de propagación
de la onda sonora. La siguiente imagen muestra los pulsos recibidos y enviados por el
sensor, de acuerdo a la hoja de datos del sensor que colocamos más arriba para su descarga.

Como se puede observar, el HC-SR04 genera un pulso en el pin marcado como “echo”
cuya duración es proporcional a la distancia medida por el sensor. Para obtener la distancia
en centímetros, solamente debemos dividir el tiempo en microsegundos entre 58 o para
obtener la distancia en centímetros (148 para pulgadas).

¿Cómo se conecta un sensor HC-SR04 con Arduino?

La conexión del sensor con Arduino es muy sencilla. Podemos realizarla utilizando un
protoboard, o directamente con alambres. Para lograr que el sensor funcione, son necesarias
4 señales:
1) Alimentación de 5 volts.
2) Tierra o común del circuito.
3) Señal de disparo (trig).
4) Señal de eco (echo).

La siguiente imagen muestra cómo queda conectado el sensor utilizando solamente cables:
 Cabe aclarar que nosotros hemos utilizado los pines 11 y 12, pero vale cualquier otra
combinación de pines. No hay mucho más que decir, ya que es bastante fácil de conectar,
solamente tener cuidado con la polaridad y posición de las señales.

Programación para sensor ultrasónico HC-SR04 y arduino utilizando librería.

El primer paso es descargar e instalar la librería newPing desde el playground de Arduino.
El proceso de instalación de una librería ya lo hemos cubierto en un tutorial anterior y no lo
expondremos nuevamente en esta entrada. El enlace de descarga de la librería y su
documentación se encuentran en esta web:
 http://playground.arduino.cc/Code/NewPing
Ya que tengamos la librería NewPing instalada, copiamos el siguiente código para probar
su funcionamiento. Hay que recordar que si cambiamos los pines de conexión con el
sensor, es necesario retocar las primeras lineas para que las señales puedan llegar a los
pines correspondientes.
Los pines de conexión deben coincidir perfectamente para que el sensor HC-SR04 y
Arduino puedan funcionar en conjunto, de lo contrario, podemos causar daños y
sobrecalentamiento a cualquiera de las dos placas: Arduino o sensor.

1 #include <NewPing.h>
2
3 /*Aqui se configuran los pines donde debemos conectar el sensor*/
4 #define TRIGGER_PIN 12
5 #define ECHO_PIN 11
6 #define MAX_DISTANCE 200
7
8 /*Crear el objeto de la clase NewPing*/
9 NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
10
11 void setup() {
12 Serial.begin(9600);
13 }
14
15 void loop() {
16 // Esperar 1 segundo entre mediciones
17 delay(1000);
18 // Obtener medicion de tiempo de viaje del sonido y guardar en variable uS
19 int uS = sonar.ping_median();
20 // Imprimir la distancia medida a la consola serial
21 Serial.print("Distancia: ");
22 // Calcular la distancia con base en una constante
23 Serial.print(uS / US_ROUNDTRIP_CM);
24 Serial.println("cm");
25 }

El código realizado con la librería NewPing queda bastante sencillo y además de aceptar el
sensor ultrasónico HC-SR04 permite utilizar la gran mayoría de los sensores que utilizan
interfaz del tipo Interfaz “con medición de pulsos” con 3 y 4 pines.
5. ANALISIS Y RESULTADOS

6. COSTOS DE IMPLEMENTACION
MATERIALES VALOR TOTAL
CANTIDAD NOMBRE UNITARIO
Y
CÓDIGO

7. CONCLUSIONES (3 CONCLUSIONES MÍNIMO)

8. BIBLIOGRAFÍA

https://geekytheory.com/arduino-leonardo
https://www.pololu.com/product/2192