TECNOLÓGICO NACIONAL DE MÉXICO
INSTITUTO TECNOLÓGICO DE TAPACHULA
ASIGNATURA:
SISTEMAS PROGRAMABLES
TRABAJO:
REPORTE DE PRÁCTICA DE SENSORES Y SUS APLICACIONES
DOCENTE:
ING. ROSEMBERG LÓPEZ JIMÉNEZ
ALUMNO:
JOSÉ ANTONIO DÍAZ
MIGUEL ANGEL GARCÍA CAMPUZANO
IVANIA
KARLA
CARRERA:
INGENIERÍA EN SISTEMAS
COMPUTACIONALES
SEMESTRE:
VII
FECHA: 05/11/2019
Contenido
INTRODUCCIÓN .................................................................................................... 4
MARCO TEÓRICO.................................................................................................. 5
Sistema electrónico: ............................................................................................ 5
Microcontrolador .................................................................................................. 6
Lenguaje de programación .................................................................................. 6
Arduino ................................................................................................................ 7
Características del micro de la placa arduino uno ............................................... 8
Memoria Flash: ................................................................................................ 9
Memoria SRAM: ............................................................................................... 9
Memoria EEPROM: ........................................................................................ 10
Los registros del microcontrolador ................................................................. 10
Alimentación:.................................................................................................. 10
Pin GND ......................................................................................................... 10
Pin 5 V............................................................................................................ 11
Entradas y salidas digitales ............................................................................ 11
Entradas analógicas ....................................................................................... 11
Salidas analógicas (PWM) ............................................................................. 12
Otros usos de los pines-hembra de la placa .................................................. 12
El botón de “reset” .......................................................................................... 13
Sensor ultrasónico HC-SR04 ............................................................................. 14
Arduino Ethernet Shield ..................................................................................... 16
Sensor infrarrojo CNY70 .................................................................................... 18
MÉTODOS ............................................................................................................ 19
Materiales .......................................................................................................... 19
RESULTADOS ...................................................................................................... 25
DISCUSIÓN .......................................................................................................... 26
CONCLUSIONES.................................................................................................. 27
REFERENCIAS ..................................................................................................... 29
ANEXOS ............................................................................................................... 30
Anexo 1: Partes de la placa arduino .................................................................. 30
INTRODUCCIÓN
Arduino es una herramienta para hacer que los ordenadores puedan sentir y
controlar el mundo físico a través de tu ordenador personal. Es una plataforma de
desarrollo de computación física (physical computing) de código abierto, basada en
una placa con un sencillo microcontrolador y un entorno de desarrollo para crear
software (programas) para la placa. Se utiliza Arduino para crear objetos
interactivos, leyendo datos de una gran variedad de interruptores y sensores y
controlar multitud de tipos de luces, motores y otros actuadores físicos. “Arduino,sus
aplicaciones”, Guía del Estudiante, Version 1.0, Parallax Inc., 2006
El verdadero potencial de un sistema electrónico reside en su capacidad para
interaccionar con su entorno, obtener información, procesarla y actuar sobre él. El
paradigma de funcionamiento del modelo anterior responde, por tanto, a un
esquema de entrada-proceso-salida. Las magnitudes físicas características del
entorno han de convertirse en señales cuya naturaleza y forma puedan ser tratadas
por los sistemas electrónicos. Paralelamente, las señales que proporcionan estos
dispositivos deben transformarse y acondicionarse para que sus efectos actúen
sobre el entorno exterior.
Los transductores son dispositivos que convierten una magnitud física en otra de
diferente naturaleza, es decir, provocan un cambio en la forma energética de la
señal. De este modo, los tipos de señales mecánicas, térmicas, magnéticas,
eléctricas, ópticas y moleculares pueden ser magnitudes objeto o destino de la
transducción.
MARCO TEÓRICO
Sistema electrónico:
Un sistema electrónico es un conjunto de: sensores, circuitería de procesamiento y
control, actuadores y fuente de alimentación. (Torrente, 2013, pág. 61).
Los sensores obtienen información del mundo físico externo y la transforman en una
señal eléctrica que puede ser manipulada por la circuitería interna de control.
Existen sensores de todo tipo: de temperatura, de humedad, de movimiento, de
sonido (micrófonos), etc. (Torrente, 2013, pág. 61).
Los circuitos internos de un sistema electrónico procesan la señal eléctrica
convenientemente. La manipulación de dicha señal dependerá tanto del diseño de
los diferentes componentes hardware del sistema, como del conjunto lógico de
instrucciones (es decir, del “programa”) que dicho hardware tenga pregrabado y que
sea capaz de ejecutar de forma autónoma. (Torrente, 2013, pág. 61).
Los actuadores transforman la señal eléctrica acabada de procesar por la circuitería
interna en energía que actúa directamente sobre el mundo físico externo. Ejemplos
de actuadores son: un motor (energía mecánica), una bombilla (energía lumínica),
un altavoz (energía acústica), etc. (Torrente, 2013, pág. 61).
La fuente de alimentación proporciona la energía necesaria para que se pueda
realizar todo el proceso descrito de “obtención de información del medio,
procesamiento, actuación sobre el medio”. Ejemplos de fuentes son las pilas,
baterías, adaptadores AC/DC, etc. (Torrente, 2013, pág. 61).
Ilustración 1 Sistema físico de un sistema electrónico. (Torrente, 2013, pág.
61)
Objetivos:
Montar el Shield Ethernet W5100
Conectarlo a nuestra LAN (red local).
Configurar los valores por DHCP.
Configurar los valores manualmente.
Microcontrolador
Un microcontrolador es un circuito integrado o “chip” (es decir, un dispositivo
electrónico que integra en un solo encapsulado un gran número de componentes)
que tiene la característica de ser programable. Es decir, que es capaz de ejecutar
de forma autónoma una serie de instrucciones previamente definidas por nosotros.
En el diagrama anterior (ilustración 1), representa un sistema electrónico, el
microcontrolador sería el componente principal de la circuitería de procesamiento y
control. (Torrente, 2013, pág. 62).
Por definición, un microcontrolador (también llamado comúnmente “micro”) ha de
incluir en su interior tres elementos básicos: CPU (Unidad Central de Proceso),
diferentes tipos de memorias (persistentes o volátiles), diferentes patillas de E/S
(entrada/salida). Un microcontrolador es un computador completo (aunque con
prestaciones limitadas) en un solo chip, el cual está especializado en ejecutar
constantemente un conjunto de instrucciones predefinidas. (Torrente, 2013, pág.
63).
Lenguaje de programación
Por “lenguaje de programación” se entiende cualquier idioma artificial diseñado para
expresar instrucciones (siguiendo unas determinadas reglas sintácticas) que
pueden ser llevadas a cabo por máquinas. Concretamente dentro del lenguaje
Arduino, encontramos elementos parecidos a muchos otros lenguajes de
programación existente (como los bloques condicionales, los bloques repetitivos,
las variables, etc.), así como también diferentes comandos –asimismo llamados
“órdenes” o “funciones” – que nos permiten especificar de una forma coherente y
sin errores las instrucciones exactas que queremos programar en el
microcontrolador de la placa. Estos comandos los escribimos mediante el entorno
de desarrollo Arduino. (Torrente, 2013, pág. 65). El lenguaje Arduino se basa
internamente en código C/C++.
Arduino
Es una placa hardware libre que incorpora un microcontrolador reprogramable y una
serie de pines-hembra (los cuales están unidos internamente a las patillas de E/S
del microcontrolador) que permiten conectar allí de forma muy sencilla y cómoda
diferentes sensores y actuadores. (Torrente, 2013, pág. 63).
Cuando hablamos de “placa Arduino”, deberíamos especificar el modelo concreto,
ya que existen varias placas Arduino oficiales, cada una con diferentes
características (como el tamaño físico, el número de pines-hembra ofrecidos, el
modelo de microcontrolador incorporado –y como consecuencia, entre otras cosas,
la cantidad de memoria utilizable–, etc.). (Torrente, 2013, pág. 64).
Los proyectos Arduino pueden ser autónomos o no. En el primer caso, una vez
programado su microcontrolador, la placa no necesita estar conectada a ningún
computador y puede funcionar autónomamente si dispone de alguna fuente de
alimentación. En el segundo caso, la placa debe estar conectada de alguna forma
permanente (por cable USB, por cable de red Ethernet, etc.) a un computador
ejecutando algún software específico que permita la comunicación entre este y la
placa y el intercambio de datos entre ambos dispositivos. Este software específico
lo deberemos programar generalmente nosotros mismos mediante algún lenguaje
de programación estándar como Python, C, Java, Php, etc., y será independiente
completamente del entorno de desarrollo Arduino, el cual no se necesitará más, una
vez que la placa ya haya sido programada y esté en funcionamiento. (Torrente,
2013, pág. 65).
Con Arduino se pueden realizar multitud de proyectos de rango muy variado: desde
robótica hasta domótica, pasando por monitorización de sensores ambientales,
sistemas de navegación, telemática, etc. Realmente, las posibilidades de esta
plataforma para el desarrollo de productos electrónicos son prácticamente infinitas
y tan solo están limitadas por nuestra imaginación. (Torrente, 2013, pág. 66).
Características del micro de la placa arduino uno
El microcontrolador que lleva la
placa Arduino UNO es el modelo
ATmega328P de la marca Atmel. La
“P” del final significa que este chip
incorpora la tecnología “Picopower”
(propietaria de Atmel), la cual
permite un consumo eléctrico
sensiblemente menor comparándolo
con el modelo equivalente sin Ilustración 2 Placa arduino uno. Recuperado de:
https://kuongshun.com/products/uno-r3-board-ch340-for-
“Picopower”, el Atmega328 (sin la arduino
“P”). De todas formas, aunque el
ATmega328P pueda trabajar a un voltaje menor y consumir menos corriente que el
Atmega328 (especialmente en los modos de hibernación), ambos modelos son
funcionalmente idénticos. (Torrente, 2013, pág. 74).
La arquitectura a la que pertenece el chip ATmega328P (y en general, toda la familia
de microcontroladores AVR) es de tipo Harvard. En este tipo de arquitectura, la
memoria que aloja los datos (en nuestro caso, la SRAM o la EEPROM) está
separada de la memoria que aloja
las instrucciones (en nuestro caso,
la Flash), por lo que ambas
memorias se comunican con la
CPU de forma totalmente
independiente y en paralelo,
consiguiendo así una mayor
Ilustración 3 Microcontrolador ATmega328P
velocidad y optimización. Otro tipo
de arquitectura (que es la que vemos en los PCs) es la arquitectura Von Neumann,
en la cual la CPU está conectada a una memoria RAM única que contiene tanto las
instrucciones del programa como los datos, por lo que la velocidad de operación
está limitada (entre otras cosas) por el efecto cuello de botella que significa un único
canal de comunicación para datos e instrucciones. (Torrente, 2013, pág. 77).
Como cada modelo de microcontrolador tiene un número y ubicación de pines
diferente, en nuestro caso concreto deberemos tener a mano la disposición de pines
del ATmega328P. Observando la ilustración 3 se puede saber qué pin es el que
recibe la alimentación eléctrica (señalado como “VCC”), qué dos pines están
conectados a tierra (los señalados como “GND”), qué pines son los de E/S
(señalados como PBx, PCx o PDx) y la existencia de otros pines más específicos
como el AVCC (donde se recibe la alimentación suplementaria para el convertidor
analógico-digital interno del chip) o el AREF (donde se recibe la referencia analógica
para dicho convertidor). También se puede observar que junto el nombre de los
pines de E/S se indica entre paréntesis las funciones especializadas que cada uno
de ellos tiene en particular (además de su función genérica de entrada/salida).
(Torrente, 2013, pág. 75).
Memoria Flash:
Memoria persistente donde se almacena permanentemente el programa que
ejecuta el microcontrolador (hasta una nueva reescritura si se da el caso). En el
caso del ATmega328P tiene una capacidad de 32KB. (Torrente, 2013, pág. 76).
Memoria SRAM:
Memoria volátil donde se alojan los datos que en ese instante el programa (grabado
separadamente en la memoria Flash, recordemos) necesita crear o manipular para
su correcto funcionamiento. Estos datos suelen tener un contenido variable a lo
largo del tiempo de ejecución del programa y cada uno es de un tipo concreto (es
decir, un dato puede contener un valor numérico entero, otro un número decimal,
otro un valor de tipo carácter… también pueden ser cadenas de texto fijas u otros
tipos de datos más especiales). Independientemente del tipo de dato, su valor
siempre será eliminado cuando se deje de alimentar eléctricamente al
microcontrolador. En el caso del ATmega328P esta memoria tiene una capacidad
de 2 KB. (Torrente, 2013, pág. 77).
Memoria EEPROM:
Memoria persistente donde se almacenan datos que se desea que permanezcan
grabados una vez apagado el microcontrolador para poderlos usar posteriormente
en siguientes reinicios. En el caso del ATmega328P esta memoria tiene una
capacidad de 1 KB, por lo que se puede entender como una tabla de 1024
posiciones de un byte cada una. (Torrente, 2013, pág. 77).
Los registros del microcontrolador
Los registros son espacios de memoria existentes dentro de la propia CPU de un
microcontrolador. Son muy importantes porque tienen varias funciones
imprescindibles: sirven para albergar los datos (cargados previamente desde la
memoria SRAM o EEPROM) necesarios para la ejecución de las instrucciones
previstas próximamente (y así tenerlos perfectamente disponibles en el momento
adecuado); sirven también para almacenar temporalmente los resultados de las
instrucciones recientemente ejecutadas (por si se necesitan en algún instante
posterior) y sirven además para alojar las propias instrucciones que en ese mismo
momento estén ejecutándose. (Torrente, 2013, pág. 78).
Es tan importante esta característica que cuando escuchamos que un
microcontrolador es de “8 bits” o de “32 bits”, nos estamos refiriendo precisamente
a este dato: al tamaño de sus registros. (Torrente, 2013, pág. 78).
Alimentación:
El voltaje de funcionamiento de la placa Arduino (incluyendo el microcontrolador y
el resto de componentes) es de 5 V.
Pin GND
Pines-hembra conectados a tierra. Es muy importante que todos los componentes
de nuestros circuitos compartan una tierra común como referencia. Estos pines-
hembra se ofrecen para realizar esta función.
Pin 5 V
Este pin-hembra se puede utilizar para dos cosas diferentes: tanto si la placa está
alimentada mediante el cable USB como si está alimentada por una fuente externa
que aporte un voltaje dentro de los márgenes de seguridad, podemos conectar a
este pin-hembra cualquier componente para que pueda recibir 5 V regulados. En
cualquier caso, la intensidad de corriente máxima generada será de 40 mA. Pero
también podemos usar este pin hembra para otra cosa: para alimentar la propia
placa desde una fuente de alimentación externa previamente regulada a 5 V sin
utilizar el cable USB ni la clavija de 2,1mm. (Torrente, 2013, pág. 87).
Entradas y salidas digitales
La placa Arduino dispone de 14 pines-hembra de entradas o salidas (según lo que
convenga) digitales, numeradas desde la 0 hasta la 13. Es aquí donde
conectaremos nuestros sensores para que la placa pueda recibir datos del entorno,
y también donde conectaremos los actuadores para que la placa pueda enviarles
las órdenes pertinentes, además de poder conectar cualquier otro componente que
necesite comunicarse con la placa de alguna manera. A veces a estos pines-hembra
digitales de “propósito general” se les llama pines GPIO (de “General Purpose
Input/Output”). (Torrente, 2013, pág. 89).
Todos estos pines-hembra digitales funcionan a 5 V, pueden proveer o recibir un
máximo de 40 mA y disponen de una resistencia “pull-up” interna de entre 20 KΩ y
50 KΩ que inicialmente está desconectada (salvo que nosotros indiquemos lo
contrario mediante programación software). (Torrente, 2013, pág. 90).
Hay que tener en cuenta, no obstante, que aunque cada pin individual pueda
proporcionar hasta 40 mA como máximo, en realidad, internamente la placa agrupa
los pines digitales de tal forma que tan solo pueden aportar 100 mA a la vez el
conjunto de los pines nº 0,1,2,3 y 4, y 100 mA más el resto de pines (del 5 al 13).
Esto quiere decir que como mucho podríamos tener 10 pines ofreciendo 20 mA a la
vez. (Torrente, 2013, pág. 90).
Entradas analógicas
La placa Arduino dispone de 6 entradas analógicas (en forma de pines hembra
etiquetados como “A0”, “A1”... hasta “A5”) que pueden recibir voltajes dentro de un
rango de valores continuos de entre 0 y 5 V. No obstante, la electrónica de la placa
tan solo puede trabajar con valores digitales, por lo que es necesaria una conversión
previa del valor analógico recibido a un valor digital lo más aproximado posible. Esta
se realiza mediante un circuito conversor analógico/digital incorporado en la propia
placa. (Torrente, 2013, pág. 90).
Salidas analógicas (PWM)
En nuestros proyectos a menudo necesitaremos enviar al entorno señales
analógicas, por ejemplo, para variar progresivamente la velocidad de un motor, la
frecuencia de un sonido emitido por un zumbador o la intensidad con la que luce un
LED. No basta con simples señales digitales: tenemos que generar señales que
varíen continuamente. La placa Arduino no dispone de pines-hembra de salida
analógica propiamente dichos (porque su sistema electrónico interno no es capaz
de manejar este tipo de señales), sino que utiliza algunos pines-hembra de salida
digitales concretos para “simular” un comportamiento analógico. Los pines-hembra
digitales que son capaces trabajar en este modo no son todos: solo son los
marcados con la etiqueta “PWM”. En concreto para el modelo Arduino UNO son los
pines número: 3, 5, 6, 9, 10 y 11. (Torrente, 2013, pág. 91).
Otros usos de los pines-hembra de la placa
Pines 2 y 3: se pueden usar, con la ayuda de programación software, para gestionar
interrupciones. (Torrente, 2013, pág. 94).
Pines 10 (SS), 11 (MOSI) , 12 (MISO) y 13 (SCK): Se pueden usar para conectar
algún dispositivo con el que se quiera llevar a cabo comunicaciones mediante el
protocolo SPI. (Torrente, 2013, pág. 94).
Pin 13: este pin está conectado directamente a un LED incrustado en la placa
(identificado con la etiqueta “L”) de forma que si el valor del voltaje recibido por este
pin es ALTO (HIGH), el LED se encenderá, y si dicho valor es BAJO (LOW), el LED
se apagará. Es una manera sencilla, y rápida de detectar señales de entradas
externas sin necesidad de disponer de ningún componente extra. (Torrente, 2013,
pág. 94).
Pin AREF: ofrece un voltaje de referencia externo para poder aumentar la precisión
de las entradas analógicas. (Torrente, 2013, pág. 94).
Pin RESET: si el voltaje de este pin se establece a valor BAJO (LOW), el
microcontrolador se reiniciará y se pondrá en marcha el bootloader. Para realizar
esta misma función, la placa Arduino ya dispone de un botón. (Torrente, 2013, pág.
94).
Una vez conocidos todos los pines-hembra de la placa Arduino UNO, es muy
interesante observar qué correspondencia existe entre cada uno de ellos y las
patillas del microcontrolador ATmega328P. Porque en realidad, la mayoría de estos
pines hembra lo que hacen es simplemente ofrecer de una forma fácil y cómoda
una conexión directa a esas patillas, y poco más. Esto se puede ver en la siguiente
ilustración; en ella se muestra cuál es el mapeado de los pines de la placa Arduino
respecto a los pines del microcontrolador ATmega328P. (Torrente, 2013, pág. 95).
Ilustración 4 Correspondencia de pines hembra con patillas del controlador
ATmega328P. (Torrente, 2013, pág. 95)
El botón de “reset”
La placa Arduino UNO dispone de un botón de reinicio (“reset”) que permite, una
vez pulsado, enviar una señal LOW al pin “RESET” de la placa para parar y volver
a arrancar el microcontrolador. Como en el momento del arranque del
microcontrolador siempre se activa la ejecución del bootloader, el botón de reinicio
se suele utilizar para permitir la carga de un nuevo programa en la memoria Flash
del microcontrolador –eliminando el que estuviera grabado anteriormente– y su
posterior puesta en marcha. No obstante, en la placa UNO no es necesario
prácticamente nunca pulsar “real y físicamente” dicho botón antes de cada carga,
ya que la placa UNO está diseñada de tal manera que permite la activación del
bootloader directamente desde el entorno de desarrollo instalado en nuestro
computador (simplemente pulsando sobre un icono de dicho entorno). (Torrente,
2013, pág. 100).
Para ver la disposición de cada parte de la placa arduino uno, se recomienda
consultar el anexo 1.
Sensor ultrasónico HC-SR04
Otro sensor digital que utiliza el método
de contar el tiempo transcurrido entre la
emisión de un pulso ultrasónico y su
posterior recepción para medir
distancias es el HC-SR04.”Dispone de
cuatro pines: “VCC” (se ha de conectar
Ilustración 5 Sensor ultrasónico. Recuperado de:
https://sandorobotics.com/producto/hc-sr04/
a una fuente de 5 V), “Trig” (responsable
de enviar el pulso ultrasónico; por tanto,
se deberá conectar a un pin de salida digital de la placa Arduino), “Echo”
(responsable de recibir el eco de ese pulso; luego se deberá conectar a un pin de
entrada digital de la placa Arduino) y “GND” (a tierra). Se puede adquirir en
IteadStudio o Elecfreaks por menos de diez euros.” (Torrente, 2013, pág. 46).
Tiene un rango de distancias sensible entre 3 cm y 3 m con una precisión de 3 mm,
su funcionamiento es el siguiente: tras emitir por el pin “trigger” una señal de 10 μs
para iniciar el envío de la señal ultrasónica, espera a detectar el eco mediante la
detección del fin de la señal HIGH recibida por el pin “echo”. (Torrente, 2013).
Funcionamiento
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
Ilustración 6 Funcionamiento del sensor HC-SR04.
existe entre el origen del sonido y el objeto. (Sensor ultrasónico HC-SR04 y Arduino,
2014).
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 pulso 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 ilustración 6 muestra los pulsos
recibidos y enviados por el sensor
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
Ilustración 7 Pulsos recibidos y enviados por el sensor HC-SR04. Recuperado de www.geekfactory.mx
obtener la distancia en centímetros, solamente debemos dividir el tiempo en
microsegundos entre 58 para obtener la distancia en centímetros (148 para
pulgadas).
Arduino Ethernet Shield
Este shield está pensado para los que le
quieren añadir a la placa Arduino UNO la
capacidad de conectarse a una red
cableada TCP/IP. Aporta la misma
funcionalidad que la placa Arduino
Ethernet pero en forma de shield
complementario acoplado a la placa
Arduino UNO. De hecho, este shield tiene
Ilustración 8: Arduino Ethernet Shield. Recuperado
de: https://sandorobotics.com/producto/sd-a024/ el mismo chip controlador W5100 que la
placa Arduino Ethernet, y se configura con
la misma librería de programación: la librería “Ethernet”, la cual ya viene por defecto
en el lenguaje Arduino. (Torrente, 2013, pág. 118)
Una vez conectado este shield sobre la placa UNO gracias a la ristra de pines que
encaja perfectamente arriba y abajo, para nuestros circuitos utilizaremos a partir de
entonces las entradas y salidas ofrecidas por los pines-hembra del shield Ethernet.
(Torrente, 2013, pág. 118)
Estas entradas y salidas tienen exactamente la misma disposición y funcionalidad
que las de la placa UNO. Incluso si fuera necesario, se podría conectar sin
problemas un segundo shield en la parte superior del shield Ethernet para seguir
sumando funcionalidad. (Torrente, 2013, pág. 118)
El procedimiento de cargar nuestros programas en el microcontrolador de la placa
UNO acoplada al shield Ethernet no varía respecto al realizado normalmente con
una placa UNO independiente: primero debemos conectar la placa UNO a nuestro
computador mediante el cable USB, y una vez cargado el programa, como siempre,
podremos seguir alimentando la placa vía USB o bien desconectarla del computador
y enchufarla a una fuente de alimentación externa. A partir de entonces, al conector
RJ-45 del shield le podremos conectar un cable de red (técnicamente, un cable de
par trenzado de categoría 5 o 6) de tipo “estándar” si deseamos comunicar el shield
a un switch o un router o de tipo “cruzado” si deseamos comunicar el shield
directamente a un computador. (Torrente, 2013, pág. 118).
Este shield requiere 5 V para funcionar. Este voltaje lo aporta la placa UNO
mediante el encaje del pin de alimentación correspondiente entre placa y shield. La
comunicación entre el chip W5100 y la placa UNO se establece mediante los pines
10,11,12 y 13 (vía SPI) por lo que estos pines no se pueden utilizar para otro
propósito. Esto implica que realmente al usar este shield tenemos 4 entradas/salidas
digitales menos. (Torrente, 2013, pág. 118).
Finalmente, indicar que este shield también dispone de su propio botón de “reset”,
el cual reinicia tanto el chip W5100 como la propia placa Arduino, y de una serie de
LEDs informativos interesantes de conocer: “PWR” (indica que la placa y el shield
reciben alimentación eléctrica), “ LINK” (indica la presencia de una conexión de red,
y parpadea cuando el shield recibe o transmite datos), “FULLD” (indica que la
conexión de red es “full duplex”), “100M” (indica la presencia de una conexión de
red de 100 megabits/s –en vez de una de 10 megabits/s–), “RX” (parpadea cuando
el shield recibe datos),”TX” (parpadea cuando el shield envía datos) y “COLL”
(parpadea cuando se detectan colisiones de paquetes en la red). (Torrente, 2013,
pág. 119).
Sensor infrarrojo CNY70
El dispositivo CNY70 es un sensor óptico infrarrojo, de un rango de corto alcance
que se utiliza para detectar colores de objetos y superficies. Su uso más común es
para construir pequeños robots
seguidor de líneas. Contiene un
emisor de radiación infrarroja
(fotodiodo) y un receptor
(fototransistor). El fotodiodo emite un
haz de radiación infrarroja, el
fototransistor recibe ese haz de luz
cuando se refleja sobre alguna
superficie u objeto. Dependiendo de la
Ilustración 9 Sensor infrarrojo CNY70. Recuperado de:
https://sandorobotics.com/producto/cny70/ cantidad de luz recibida por el
fototransistor el dispositivo envía una señal de retorno a una tarjeta controladora
como Arduino. (Sensor Infrarrojo CNY70, 2019).
Relevador
Un relevador es un aparato eléctrico que funciona como un interruptor pero que es
accionado eléctricamente. El relé permite abrir o cerrar contactos mediante un
electroimán, Fue desarrollado en la primera mitad del siglo XIX por el físico
norteamericano Joseph Henry, a través de una bobina y un electroimán. Lo que
hace la bobina es crear un campo magnético que lleva los contactos a establecer
una conexión. El electroimán, por su parte, permite el cierre de los contactos.
(Mecafenix, 2017)
Un relevador funciona como un interruptor controlado por un circuito eléctrico en el
que, por medio de una bobina y un electroimán, se acciona un juego de uno o varios
contactos que permiten abrir o cerrar otros circuitos eléctricos independientes. Dado
que el relé es capaz de controlar un circuito de salida de mayor potencia que el de
entrada, puede considerarse, en un amplio sentido, como un amplificador eléctrico.
(Mecafenix, 2017)
Ventajas
Permite el control de un dispositivo a distancia. No se necesita estar junto al
dispositivo para hacerlo funcionar.
Es activado con poca corriente, sin embargo puede activar grandes
máquinas que consumen gran cantidad de corriente.
Con una señal de control, puedo controlar varios relés a la vez.
MÉTODOS
Material Requerido:
Arduino Uno o similar. Esta sesión
acepta cualquier otro modelo de
Arduino.
Una Protoboard.
Algunos cables de Protoboard.
Relevador
Sensor ultrasónico HC-SR04
Un Shield Ethernet (W5100).
Bombilla de 75 Watts
Sensor infrarrojo CNY70
1 metro de cable de cobre
Fuente de alimentación de
5V
Conexión del HC-SR04 con la placa arduino uno
A continuación se
detallan los pasos
para conectar el
sensor HC-SR04 con
una base de datos,
guardar registros y
consultarlos Ilustración 10 Conexión de sensor ultrasónico con la placa arduino uno.
Recuperado de: https://naylampmechatronics.com/blog/10_Tutorial-de-Arduino-
mediante una página y-sensor-ultras%C3%B3nico-HC-S.html
web en tiempo real
El sensor HC-SR04 es un sensor de distancia de bajo costo, su uso es muy
frecuente en la robótica, utiliza transductores de ultrasonido para detectar objetos.
Su funcionamiento consiste en emitir un sonido ultrasónico por uno de sus
transductores, y esperar que el sonido rebote de algún objeto presente, el eco es
captador por el segundo transductor. La distancia es proporcional al tiempo que
demora en llegar el eco.
Se empezará insertando el sensor ultrasónico en un protoboard y con cables se
hace las siguientes conexiones:
Trigger del sensor al pin 2 del arduino
Echo del sensor al pin 3 del arduino
Ilustración 11 Conexión física del sensor HC-SR04 con la placa arduino.
Programación del sensor HC-SR04 en el IDE de arduino
Para poder comprender la programación a realizar es necesario conocer los
fundamentos matemáticos que sustentan el algoritmo a realizar por tanto se
describirá a continuación.
El sensor se basa simplemente en medir el tiempo entre el envío y la recepción de
un pulso sonoro. Sabemos que la velocidad del sonido es 343 m/s en condiciones
de temperatura 20 ºC, 50% de humedad, presión atmosférica a nivel del mar.
Transformando unidades resulta. (Llamas, 2015).
𝑚 𝑐𝑚 1𝑠 1 𝑐𝑚
343 ∗ 100 ∗ =
𝑠 𝑚 1000000𝜇𝑠 29.2 𝜇𝑠
El sonido tarda 29,2 microsegundos en recorrer un centímetro. Por tanto, podemos
obtener la distancia a partir del tiempo entre la emisión y recepción del pulso
mediante la siguiente ecuación. (Llamas, 2015).
𝑇𝑖𝑒𝑚𝑝𝑜(𝜇𝑠)
𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎(𝑐𝑚) =
29.2 ∗ 2
El motivo de divir por dos el tiempo (además de la velocidad del sonido en las
unidades apropiadas, que hemos calculado antes) es porque hemos medido el
tiempo que tarda el pulso en ir y volver, por lo que la distancia recorrida por el pulso
es el doble de la que queremos medir. (Llamas, 2015).
𝑇𝑖𝑒𝑚𝑝𝑜(𝜇𝑠)
𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎(𝑐𝑚) =
58.4
Código sin utilizar librerías (Sin conexión a base de datos)
/**
El presente código realiza la medición de distancia con un sensor
ultrasónico HC-SR04 conectado al arduino. Este ejemplo no utiliza
librerías especiales para el sensor, solamente se utiliza la función
"pulsein" para medir la longitud del pulso de eco, en esta versión
aún no se ha configurado la conexión del arduino a una base de datos.
*/
// DECLARACION DE VARIABLES PARA PINES
const int pinecho = 3;
const int pintrigger = 2;
const int pinled = 13;
// VARIABLES PARA CALCULOS
unsigned int tiempo, distancia;
void setup() {
// PREPARAR LA COMUNICACION SERIAL
Serial.begin(9600);
// CONFIGURAR PINES DE ENTRADA Y SALIDA
pinMode(pinecho, INPUT);
pinMode(pintrigger, OUTPUT);
pinMode(13, OUTPUT);
}
void loop() {
// ENVIAR PULSO DE DISPARO EN EL PIN "TRIGGER"
digitalWrite(pintrigger, LOW);
delayMicroseconds(2);
digitalWrite(pintrigger, HIGH);
// EL PULSO DURA AL MENOS 10 uS EN ESTADO ALTO
delayMicroseconds(10);
digitalWrite(pintrigger, LOW);
// MEDIR EL TIEMPO EN ESTADO ALTO DEL PIN "ECHO" EL PULSO ES
//PROPORCIONAL A LA DISTANCIA MEDIDA
tiempo = pulseIn(pinecho, HIGH);
// LA VELOCIDAD DEL SONIDO ES DE 340 M/S O 29 MICROSEGUNDOS POR
//CENTÍMETRO
//DIVIDIMOS EL TIEMPO DEL PULSO ENTRE 58, TIEMPO QUE TARDA //RECORRER
IDA Y VUELTA UN CENTÍMETRO LA ONDA SONORA.
distancia = tiempo / 58;
// ENVIAR EL RESULTADO AL MONITOR SERIAL
Serial.print(distancia);
Serial.println(" cm");
delay(200);
// ENCENDER UN LED CUANDO SE CUMPLA CON CIERTA DISTANCIA
if (distancia <= 15) {
digitalWrite(13, HIGH);
delay(500);
} else {
digitalWrite(13, LOW);
}
}
Código con librerías (Sin conexión a base de datos)
#include <NewPing.h>
/*Aqui se configuran los pines donde debemos conectar el sensor*/
#define TRIGGER_PIN 12
#define ECHO_PIN 11
#define MAX_DISTANCE 200
/*Crear el objeto de la clase NewPing*/
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
void setup() {
Serial.begin(9600);
}
void loop() {
// Esperar 1 segundo entre mediciones
delay(1000);
// Obtener medicion de tiempo de viaje del sonido y guardar en variable uS
int uS = sonar.ping_median();
// Imprimir la distancia medida a la consola serial
Serial.print("Distancia: ");
// Calcular la distancia con base en una constante
Serial.print(uS / US_ROUNDTRIP_CM);
Serial.println("cm");
}
RESULTADOS
DISCUSIÓN
CONCLUSIONES
REFERENCIAS
Llamas, L. (16 de Junio de 2015). MEDIR DISTANCIA CON ARDUINO Y
SENSOR DE ULTRASONIDOS HC-SR04. Obtenido de Luisllamas.es:
https://www.luisllamas.es/medir-distancia-con-arduino-y-sensor-de-
ultrasonidos-hc-sr04/
Mecafenix, F. (17 de Abril de 2017). ¿Que es un relevador y como funciona?
Obtenido de Ingmecafenix.com: https://www.ingmecafenix.com/electricidad-
industrial/relevador/
NewPing Arduino Library for Arduino. (02 de Octubre de 2019). Obtenido de
Bitbucket.org: https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home
Sensor Infrarrojo CNY70. (Noviembre de 2019). Obtenido de Sandorobotics.com:
https://sandorobotics.com/producto/cny70/
Sensor ultrasónico HC-SR04 y Arduino. (16 de Mayo de 2014). Obtenido de
Geekfactory.mx: https://www.geekfactory.mx/tutoriales/tutoriales-
arduino/sensor-ultrasonico-hc-sr04-y-arduino/
Torrente, O. (2013). Arduino. Curso prático de formación. México: Alfaomega.
ANEXOS
Anexo 1: Partes de la placa arduino
Ilustración 12 Partes de la placa arduino uno. Recuperado de: https://adichip.net/tienda/wp-
content/uploads/2019/04/Arduino-UNO.jpg
