Código FDE 089

INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-27

DESARROLLO DE IoT, GSM, IDS, GPIO CON

RASPBERRY PI

David Saldarriaga Velásquez

Tecnología Electrónica

Director del trabajo de grado

Alexander Arias Londoño

IEo, MSc.

INSTITUTO TECNOLÓGICO METROPOLITANO

Medellín
2019
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

2
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

RESUMEN
Se trabaja la orientación hacia el IoT con base a varios proyectos de investigación
propuestos en el semillero MMCC y el grupo de investigación C3, las actividades a
desarrollar sobre este trabajo se harán con la Rasberry pi 3b+ con lenguajes Python y
Node JS. Los proyectos de investigación manejados por el grupo requieren él envió de
datos de un sensor DHT11 a la nube por medio de una conexión con la plataforma IoT y
visualizarla en una plataforma web llamada asksensors, también con el módulo GSM
SIM800L enviar y recibir llamadas y mensajes de texto con comandos AT. Por otro lado, se
implementa la Rasberry Pi como un IDS para apoyar la ciberseguridad, detectando el
tráfico de una red. Y por último se implementa un robot seguidor de línea velocista
desarrollado para competencia de la Semana de Ingeniería del ITM (SII) para representar
el semillero y el grupo. Los proyectos servirán de base para que otros integrantes del
grupo puedan trabajar las plataformas de IoT.

Palabras clave: IoT, Python, Node JS, GSM, sim800l, IDS, AT, DHT, Robot.

3
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

RECONOCIMIENTOS

El amor recibido, la dedicación y la paciencia con la que cada día se preocupaban mis
padres por mi avance y desarrollo académico, es simplemente único y se refleja en mi día
a día.

Gracias a mis padres por ser los principales promotores de mis sueños, gracias a ellos
por cada día confiar y creer en mí y en mis expectativas, por despertar en mí el interés por
leer, la curiosidad por investigar, la pasión por descubrir el mundo, y sobre todo gracias
por desear y anhelar siempre lo mejor para mi vida, gracias por cada consejo y por cada
una de sus palabras alentadoras.

Gracias a Dios por la vida de mis padres, y gracias a mis padres por permitirme
conocer de Dios y de su infinito amor.
Gracias a la vida por este nuevo triunfo, gracias a todas las personas que me apoyaron
y que compartieron junto a mí sus enseñanzas y mis logros en estos años, así como
quienes han estado para darme una voz de aliento en los momentos difíciles.

A mis profesores, gracias, por su disposición para trabajar con nosotros y formar un
gran equipo de aprendizaje, sin su amable y valiosa colaboración el presente trabajo de
grado no se habría podido llevar a cabo.
Todos hicieron posible llegar a este punto, fin de una etapa más, pero comienzo de
una nueva que viviré con mayor intensidad.

4
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ACRÓNIMOS

AT Comandos para configurar y parametrizar módems

DHT Humidity and Temperature Digital Sensor

GPIO General purpose input/output

GSM Sistema global para comunicaciones móviles

IDS Un sistema de detección de intrusiones (Intrusion Detection System)

IoT Internet of Things

MMCC Semillero de Modelamiento Matemático y Cómputo Científico
NPM Node Package Manager
Node.js Entorno de código abierto, multiplataforma, entorno de ejecución de
JavaScript
RPi Raspberry Pi 3B+
SII Semana de Ingeniería del ITM

5
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

TABLA DE CONTENIDO

1. INTRODUCCIÓN......................................................................................................15
Objetivo General............................................................................................................16
Objetivos Específicos......................................................................................................16
2. MARCO TEÓRICO....................................................................................................17
2.1. Boards de desarrollo MiniPC..............................................................................17
2.2. Características de la Raspberry Pi (RPi)..............................................................19
2.3. Raspbian.............................................................................................................20
2.4. Python.................................................................................................................22
2.5. Sensor DHT11.....................................................................................................22
2.6. Node JS...............................................................................................................24
2.7. Módulo GSM SIM800L........................................................................................25
2.8. Sistemas Detectores de Intrusos........................................................................27
2.9. Robot Seguidores de línea..................................................................................28
EVENTOS DE ROBÓTICA EN COLOMBIA.....................................................................28
RUNIBOT.................................................................................................................28
ROBOTEX.................................................................................................................30
3. METODOLOGÍA.......................................................................................................32
3.1. Instalación de Raspbian en la RPi.......................................................................32
PASOS PARA LA INSTALACIÓN DE RASPBIAN.............................................................33
Paso 1. Instalación de Raspbian:............................................................................33
Paso 2. Formatear SD Card:....................................................................................34
Paso 3. Flasheo con Balena Etcher:........................................................................34
Paso 4. Configuración de Rasbian:.........................................................................35
Paso 5. Actualización de software Rasbian:...........................................................36
3.2. Manejo de la GPIO con Rpi y Python..................................................................36
3.3. Montaje DHT11 Python..........................................................................................40
3.3.1. Pasos para montar el DHT11 en la RPi con Python..........................................40
Paso 1. Montaje Rpi y DHT:....................................................................................40
Paso 2. Instalación de librería DHT desde Git:.......................................................41
Paso 2. Comprobación del sensor DHT desde la consola:......................................41
Paso 3. Codificación en Python para leer el sensor desde el Idle..........................42
3.3.2. Alarmas con el DHT11 en la RPi y Python........................................................44
3.4. Montaje IoT con Rpi y Plataforma AskSensor por medio de NodeJS.....................45
Paso 1. Creación de cuenta en AskSensors:...........................................................46
Paso 2. Creación de un nuevo sensor en AskSensors:...........................................46
Paso 3. Datos necesarios para conexión (APiKey)..................................................47
6
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Paso 4. Creación de módulos y gráficos en askSensors:........................................47

Paso 5. Verificación de las versiones de Node JS en la Rpi:...................................48
Paso 6. Creación del archivo iot.js para ejecución en la Rpi y Asksensors por medio
de NodeJS:.....................................................................................................................49
Paso 5. IoT con DHT y Node JS:..............................................................................51
Paso 6. Liberia DHT Node JS:..................................................................................51
3.5 Montaje GSM y Rpi..................................................................................................53
CONFIGURACIÓN DEL MODULO SIM800L CON RPi y Python y picocom..................54
Paso 1. Actualización repositorios y paquetes:......................................................54
Paso 2. Aplicación Picocom descarga y configuración con comandos AT:............59
Códigos En Python para enviar y recibir llamadas con la SIM800L y guardar en un log:
...........................................................................................................................................61
3.6. IDS CON SURICATA EN PLATAFORMA IoT RASPBERRY...........................................66
Paso 1. Instalación y configuración:.......................................................................67
Paso 2. Instalación de suricata en Rpi y Configuración con comandos :................67
Paso 3. Habilitacion “Port Mirroring” en Switch de cisco......................................69
Paso 4. Ejecución de suricata en Rpi y sus reglas personalizadas:.........................73
Paso 5. Capturando tráfico de la Red:....................................................................77
3.7 Montaje Robot Seguidor De Línea...........................................................................78
Costos y presupuestos...............................................................................................80
ACERCA DEL ROBOT Y SUS CARACTERÍSTICAS...........................................................80
Escogiendo el microcontrolador................................................................................81
Diseño de chasis y montaje superficial......................................................................82
Chasis creado..............................................................................................................83
Regleta de 16 sensores..............................................................................................83
motores......................................................................................................................84
Proteus.......................................................................................................................85
Programando el Seguidor de Línea y su código con control PD................................86
Pruebas y pista de competencia................................................................................87
4. RESULTADOS Y DISCUSIÓN.....................................................................................88
5. CONCLUSIONES, RECOMENDACIONES Y TRABAJO FUTURO.................................91
REFERENCIAS..................................................................................................................93
ANEXOS..........................................................................................................................96
ANEXO 1.........................................................................................................................96
ANEXO2..........................................................................................................................97
ANEXO 3.......................................................................................................................100
ANEXO 4.......................................................................................................................100
ANEXO 5.......................................................................................................................102
ANEXO 6.......................................................................................................................102
ANEXO 7.......................................................................................................................102
ANEXO 8.......................................................................................................................103
ANEXO 9.......................................................................................................................104

7
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ANEXOS 10...................................................................................................................106
ANEXO 11.................................................................................................................118

8
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Tabla de Ilustraciones
Ilustración 1. Top 10 mejores MiniPc............................................................................19

Ilustración 2. VNC...........................................................................................................21

Ilustración 3. Pines del DHT11.......................................................................................22

Ilustración 4. Tarjeta SIM800L.......................................................................................25

Ilustración 5. Infraestructura IDS...................................................................................27

Ilustración 6. Pista competencia Runibot......................................................................29

Ilustración 7. Pista Robotex...........................................................................................30

Ilustración 8.Imagen de Rasbian....................................................................................33

Ilustración 9. Flash de imagen Rasbian a Micro SD.......................................................34

Ilustración 10.Configuración Rasbian............................................................................35

Ilustración 11. Desktop Sistema Rasbian.......................................................................36

Ilustración 12. Pines de Rpi............................................................................................37

Ilustración 13. Código secuencia de pines 1, Código Anexo 1.......................................38

Ilustración 14. Código secuencia de pines 2, Código Anexo..........................................38

Ilustración 15. Código secuencia de pines 3, Código Anexo 1.......................................39

Ilustración 16. Montaje Físico GPIO...............................................................................39

Ilustración 17. Montaje DHT y Rpi.................................................................................41

Ilustración 18. Prueba DHT11 y Rpi...............................................................................42

Ilustración 19. Shell de Python 3.7.3, con código DHT..................................................43

9
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 20. Código 1 DHT11 + GPIO, Código Anexo 2..............................................44

Ilustración 21. Código 2 DHT11 + GPIO + Alarmas, Código Anexo 2.............................45

Ilustración 22. Creación de nuevo sensor en asksensor................................................46

Ilustración 23. Api Key In...............................................................................................47

Ilustración 24. Gráfico lineal..........................................................................................48

Ilustración 25. Nuevo archivo iot.js...............................................................................49

Ilustración 26. Código Https, Código Anexo 3...............................................................50

Ilustración 27. Grafica de muestra HTTPS.....................................................................50

Ilustración 28. Código 1 HTTPS + DHT11, Código Anexo 4............................................51

Ilustración 29. Código 2 HTTPS + DHT11, Código Anexo 4............................................51

Ilustración 30. Ejemplos datos de temperatura y humedad.........................................52

Ilustración 31. Datos transferidos desde las Rpi, Temperatura y Humedad.................52

Ilustración 32. Conexión Sim800l y Rpi..........................................................................54

Ilustración 33. Configuración UART Rpi.........................................................................55

Ilustración 34. Deshabilitar UART..................................................................................56

Ilustración 35.Opciones de Interfaz...............................................................................57

Ilustración 36. Serial.......................................................................................................57

Ilustración 37. No al login Shell......................................................................................58

Ilustración 38. Habilitar el puerto serial hardware........................................................58

Ilustración 39. Reiniciar..................................................................................................58

Ilustración 40. Picocom..................................................................................................59

10
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 41, código enviar msm, código ANEXO 5.....................................................61

Ilustración 42, código .log, código ANEXO 6..................................................................62

Ilustración 43. Enviar mensaje con .log, ANEXO 7.........................................................62

Ilustración 44. Código para enviar llamadas, Código ANEXO 8.....................................63

Ilustración 45. Código 1 enviar msm para encender leds, Código ANEXO 9.................64

Ilustración 46. Código 2 enviar msm para encender leds, Código ANEXO 9.................65

Ilustración 47. Gráfico IDS..............................................................................................66

Ilustración 48. Componentes usados para IDS..............................................................67

Ilustración 49. Creación de nuevo usuario....................................................................68

Ilustración 50. Eliminar usuario pi.................................................................................68

Ilustración 51. Habilitar SSH...........................................................................................68

Ilustración 52. Modo promiscuo....................................................................................68

Ilustración 53. Instalación de suricata...........................................................................69

Ilustración 54. Actualización de reglas..........................................................................69

Ilustración 55. Tareas contab.........................................................................................69

Ilustración 56. Verificación de reglas.............................................................................75

Ilustración 57. Ping de la maquina atacante..................................................................75

Ilustración 58. Servicios AF y NF....................................................................................75

Ilustración 59. Configuración home y external..............................................................76

Ilustración 60 Interfaces con todo el trafico..................................................................77

Ilustración 61. Custom.rules..........................................................................................77

11
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 62. Escaneo de tráfico de la red...................................................................78

Ilustración 63. Dspic 30f4011.........................................................................................81

Ilustración 64. Peso del robot........................................................................................82

Ilustración 65. PCB chasis del robot...............................................................................83

Ilustración 66. Circuito de Sensor..................................................................................83

Ilustración 67. Montaje en Proteus...............................................................................85

Ilustración 68. Pista de competencia semana de la ingenieria.....................................87

Ilustración 69. Curso de InnovaDomotic........................................................................88

Ilustración 70. Prueba llamada comando AT.................................................................89

Ilustración 71. Puertos UART.........................................................................................89

Ilustración 72. Erros al ejecutar el codigo......................................................................90

Ilustración 73. Resultado de trafico de web..................................................................90

12
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

1. INTRODUCCIÓN

Este proyecto pretende mostrar el trabajo de varios proyectos de investigación dentro

del Semillero MMCC y el grupo de Investigación C3, los cuales fueron propuestos por los
líderes del grupo y del semillero de Investigación. Las actividades de este trabajo giran en
torno a IoT, Robótica, Comunicaciones y Ciberseguridad. “IoT es, en esencia, que cada
cosa que hay en el planeta tenga la capacidad de recolectar toda la información que
pueda tomar sobre su entorno, y la almacene, gestione e intérprete de forma inmediata,
barata y sostenible” [ CITATION Rut19 \l 22538 ]. Los temas de este proyecto de
comunicaciones se mezclan con el IoT, para lograr al final hacer un montaje que permita
detectar el tráfico de una red, todo con las tendencias de hacer viables proyectos de bajo
costo a las Pymes o empresas spin off. Los entregables de este proyecto servirán de base a
los compañeros del semillero para realizar actividades investigativas sobre plataformas
Raspberry Pi y DsPic.

Se toma como base proyectos de maestría dirigidos a seguridad informática con IOT
apoyados dentro del semillero acompañado con la tarjeta Rasberry pi 3b+. Se
implementará con lenguajes de programación Python, JavaScript con node.js. Los
proyectos de investigación manejados por el grupo requieren envió de datos de un sensor
DHT11 a la nube por medio de una conexión con la plataforma IOT, implementación de la
conexión con módulo GSM y Rasberry para enviar y recibir mensajes y llamadas con
comandos AT. Creación desde Python de archivos logs para manejo de alarmas y hacer
entrega de esto para proyecto de seguridad informática.

El producto "Desarrollo de Seguidor de línea robot" se diseñó para competir en la

semana de ingeniería del ITM, corresponde a un prototipo que se acopla a las necesidades
del departamento de electrónica y telecomunicaciones. Se desarrollará un robot seguidor

13
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

de línea para incentivar a estudiantes de electrónica a participar en eventos organizados

por el ITM y así mismo para adquirir experiencia en el diseño.

Objetivo General

Desarrollar implementaciones de GPIO, IoT, GSM e IDS con Raspberry Pi y un Robot

seguidor de línea con un DsPic.

Objetivos Específicos

 Montar un sistema operativo Raspbian funcional con manejo de GPIO con Python
en una RaspBerry Pi 3B+.
 Implementar un sistema IoT con sensor DHT11 en Python y en Node JS en una
Raspberry Pi 3B+ (Rpi).
 Realizar un sistema de alerta con GSM con el módulo SIM800L y comunicación con
la Rpi.
 Desarrollar un sistema IDS para detección de tráfico en una red de computadores
con la RPi.
 Diseñar un Robot seguidor de línea con un DsPic.

14
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

2. MARCO TEÓRICO

En este capítulo se abordan los aspectos más relevantes de cada objetivo específico

planteado. Se empieza con una descripción de las boards de desarrollo de MiniPC.

Entonces se explican las características de la Raspberry Pi (RPi) y el sistema operativo

Raspbian. Los lenguajes en que se realizaron los diseños de los programas son Python y

Javascript, para el último se muestran algunas características de Node JS como framework

de trabajo. En las conexiones GSM se utilizó la tarjeta SIM800L y se habla un poco de ella.

Para la Ciberseguridad se trabaja con los IDS y se presentan las definiciones básicas y por

último se habla de las competencias que se realizan en el medio y algunas reglas para

participar.

2.1. Boards de desarrollo MiniPC

En la Tabla 1 están las diferencias entre tres MiniPc o microcontroladores, cada uno

tiene sus ventajas y desventajas; donde se observa que la mejor placa de desarrollo

respecto a su procesador es las Rasberry Pi 3 b+ [ CITATION dbb \l 3082 ].

15
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Tabla 1. Rpi vs Orange vs Beagle.

Board CPU RAM WIFI GPIO SoC GPU
Raspberry ARM Cortex- 1GB 802.11b/g/n 40 Broadco VideoCore
Pi A53 (64-bit) m BCM2837 IV
1.2GHz quad core
Orange Pi ARM Cortex- 1GB 802.11b/g/n 40 AllWinn Mali-400
A7 (32-bit) er H3 MP2
1.6GHz quad core
Beagle ARM Cortex- 2GB NO TIENE 92 TI PowerVR
Bone A8 (32-bit) AM3358/9 SGX530
1GHz single core

“Comparando la Rpi con la Orange pi prime se ve que son muy parecidos, la Orange pi
es un claro rival para la Rasberry pi, con varias características a su favor, tales como; es
más económica, hablando en nivel de hardware, esta tarjeta supera la Rpi, porque tiene
una mejor GPU y supera por 1GB de memoria RAM, por otro lado la Orange Pi ofrece
mejor conectividad por cable gracias a su tarjeta de red Gigabit Ethernet, pero tiene una
entrada USB 2.0 menos que su rival, también la Orange aunque no se le pueda instalar
Raspbian (uno de los mejores sistemas operativos para miniordenadores); está si es
compatible con Ubuntu y Android”[ CITATION Rub17 \l 3082 ].

Sin embargo, se ha escogido la Rasberry pi 3 b+, ya que se tuvo la facilidad de acceso

a ella, es una de las tarjetas más reconocidas en el mercado y ha cumplido todas las

expectativas que se necesitan. También se vio en la ilustración 1 como la Rpi fue elegida

de primera en el top 10 de las mejores placas, compitiendo con otras muy buenas

tarjetas.” [ CITATION Dan18 \l 9226 ]

16
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 1. Top 10 mejores MiniPc.

2.2. Características de la Raspberry Pi (RPi)

“Este micro-ordenador es muy económico para ser la revolución de los MiniPc en el

mundo, con esta tarjeta se hace posible adaptarse fácilmente a las necesidades de los

usuarios, ya sea para jugar, programar, hace de función de un servidor casero, entre otras.

Esta tarjeta fue lanzada en el año 2012 y la versión 3b+ en el 2018 con una actualización

centrada en mejorar la conectividad.”[ CITATION Hardzone \l 9226 ]

Las características de esta versión son:

 CPU + GPU: Broadcom BCM2837B0, Cortex-A53 (ARMv8) 64-bit SoC @ 1.4GHz

 RAM: 1GB LPDDR2 SDRAM

 Wi-Fi + Bluetooth: 2.4GHz y 5GHz IEEE 802.11.b/g/n/ac, Bluetooth

 4.2, BLE

17
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

 Ethernet: Gigabit Ethernet sobre USB 2.0 (300 Mbps)

 GPIO de 40 pines

 HDMI

 4 puertos USB 2.0

 Puerto CSI y DSI para conectar una cámara y una pantalla táctil

 Salida de audio estéreo y vídeo compuesto

 Micro-SD

 Power-over-Ethernet (PoE)

 procesador 200 Mhz

La RPi tiene dos novedades que pueden resultar útiles para los desarrolladores:

 Un chip inalámbrico, fabricado por Adafruit, que ofrece Bluetooth 4.2 y BLE, además

de Wi-Fi de 5 Ghz para una mayor velocidad.

 Gigabit Ethernet controlado por el chip USB 2.0 que, aunque no alcanza los
1000Mbps, sí ofrece sin problema 300 Mbps.” [ CITATION Hardzone \l 9226 ]

2.3. Raspbian

Es un sistema operativo que se basa en una distribución GNU/Linux llamada Debian.

Este consta de dos versiones para la instalación en la RPi [ CITATION Erg19 \l 9226 ]:
 Versión Rasbian Pixel: Tiene un entorno gráfico completo, donde se puede
visualizar el menú, iconos, fondos de pantalla, entre otros como un ordenador de
sobremesa.
 Versión Rasbian Lite: No tiene entorno gráfico, esta versión es en modo consola,
pesando menos y más ligera, es ara usuarios avanzados con gran conocimiento en
Linux que utilizan la Rpi como servidor.

18
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

 Permite manejo de VNC para conexiones de Escritorio remoto Virtual, para

descargar la aplicación en la página:
https://www.realvnc.com/es/connect/download/viewer/
“VNC es un programa de software libre basado en una estructura cliente-servidor
que permite observar las acciones del ordenador servidor remotamente a través
de un ordenador cliente”.[ CITATION wik19 \l 3082 ]

Ilustración 2. VNC

En la Ilustración 2 se muestra la aplicación VNC Viewer, para llenar la información en

VNC Server se digital el IP de la conexión Wifi de la Rpi; la IP se averigua con el comando

“ifconfig”, escoger VNC en connection Mode.

La aplicación VNC Viewer sirve para entrar a la imagen de Rasbian en imagen

compartida con comunicación VNC y verla en cualquier otro dispositivo electrónico, por

ejemplo, un computador o celular.

 Acepta conexiones SSH y este nos sirve para conexiones remotas desde consola o
Shell de comandos y entrar a la raíz de la Rpi.

19
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

2.4. Python

Es un lenguaje potente y avanzado de programación que se orienta al fácil

entendimiento y al orden en la implementación de código. Posee estructuras de datos de

alto nivel, enfocado a la programación de objetos. Es un tipo de lenguaje interpretado,

dinámico y elegante, hace que sea perfecto e ideal para la creación se scripts y el

desarrollo rápido de aplicaciones.

Para los principales sistemas operativos la interpretación de Python se amplía con

nuevas funciones y tipos de datos implementados con C o C++.

Python también es también adecuado como lenguaje de extensión de aplicaciones.

Por otra parte, nos ofrece la instalación de paquetes y librerías fáciles de descargar por

medio de pip [ CITATION Pyt19 \l 9226 ].

2.5. Sensor DHT11

El DHT11 tiene dos sensores uno de humedad y otro de temperatura. El sensor de

humedad es capacitivo y el de temperatura es un termistor. Tiene un pequeño
microcontrolador interno para hacer el tratamiento de las señales. La comunicación de
salida se maneja por medio del protocolo “One Wire”, el cual es un protocolo en el que la
señal de salida es digital por un solo cable como se muestra en la Ilustración 3. Pines del
DHT11.

Ilustración 3. Pines del DHT11.

20
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

La ilustración 3 muestra las conexiones de del DHT; VDD alimentación, DATA cable de
datos, GND tierra.
Las características más relevantes del sensor DHT11 son:
 Alimentación de 3V a 5V
 Precisión de temperatura de ±2 °C

 Rango de medida humedad de 20% a 90% RH/1%RH

Tamaño de 12 x 15.5 x 5.5mm” [ CITATION omn19 \l 9226 ]

Las características más detalladas del sensor se muestran en la Tabla 2 [ CITATION Ato19 \l
22538 ].

Tabla 2. DHT11 Especificaciones.

Especificaciones Rangos
Model ATO-TAHS-DHT11
Weight 1g
Dimension (L*W*H) 12.6*6.0*16.1mm
Communication mode One-wire
Supply voltaje DC 3.3-5.5V
Measuring range of relative
0~99.9%RH
humidity
Measuring range of temperature 0~50℃
Accuracy of humidity ±5%RH
Accuracy of temperatura ±2℃
Resolution 0.1℃/0.1%RH
Long-term stability ＜0.5%RH/year, ＜0.3℃/year
Power consumption ＜300μA
Sampling period 2s
Response time ＜6s
Housing material PC
Temperature: 0~50℃, humidity: 0~99.9% no
Working environment
condensation
Storage environment Temperature: 0~50℃, humidity: ＜95%RH
1 red: VDD, 2 yellow: DATA (serial data), 3: NC, 4 black:
Wiring
GND

21
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

2.6. Node JS

“Node JS es un entorno en tiempo de ejecución de JavaScript orientado a eventos

asíncronos, con I/O de datos basado en el motor v8 de Google, está diseñado para
construir aplicaciones en red escalables, como por ejemplo servidores web”[ CITATION
nod19 \l 9226 ].

NodeJS es un entorno de ejecución JavaScript del lado del servidor. Recordemos que
JavaScript nace inicialmente en la década de los noventas por los desarrolladores de
Netscape, este fue creado para resolver problemas simples como validación de
formularios, alertas y pequeños problemas de lógica de programación. Sin embargo,
JavaScript ha venido evolucionando hasta convertirse en un lenguaje de programación
completo. NodeJS es creado por Ryan Lienhart Dahl, quien tuvo la gran idea de tomar el
motor de JavaScript de Google Chrome llamado V8, y montarlo como el Core de NodeJS
[ CITATION Bla17 \l 22538 ].

Node Package Manager (NPM) es el gestor de paquetes de Node JS. Es el ecosistema

más grande de librerías de código abierto en el mundo. NodeJS ha representado todo un
cambio de paradigma, ya que tiene como principal característica el procesamiento
asíncrono en casi la totalidad de sus tareas. Para ello, NodeJS utiliza únicamente un hilo de
ejecución y procesamiento de entrada y salida asíncrono. Con lo cual, NodeJS no realiza
bloqueos en el procesamiento [ CITATION Bla17 \l 22538 ].

Las ventajas y desventajas de NodeJS se escriben en la siguiente tabla, para mayor

detalle se puede leer el artículo de [ CITATION Bla17 \l 22538 ].

22
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Tabla 3. NodeJS Ventajas y Desventajas.

Ventajas Desventajas
Open Source Tipos Dinámicos
Optimización de los recursos CallBacks
Desarrollos ágiles Refactor
FullStack Librerías Estándar
Modularidad Arquitectura

2.7. Módulo GSM SIM800L

“Este módulo de telefonía nos posibilita enviar y recibir llamadas y mensajes de texto,
usando la Rasberry pi 3b+ para su control de 3-5V con una interfaz serial UART que pueda
mandar información bidireccional con los pines Rx/Tx.
Solo trabaja con tecnología 2G a una velocidad en baudios dependiendo de tu país,
controlado con comandos AT desde distintas aplicaciones tales como picocom y
minicom[ CITATION Fra18 \l 9226 ]. LA tarjeta SIM800L se muestra en la Ilustración 4.

Ilustración 4. Tarjeta SIM800L.

23
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

El módulo SIM800L puede conectarse a redes 2G para hacer y recibir llamadas, al igual

que conectarse a datos a una velocidad de 2G. Las características del módulo SIM800L

son:

 Voltaje de Operación: 3.4V ~ 4.4V DC.

 Consumo de corriente (max): 500 mA.

 Consumo de corriente (sleep): 0.7 mA.

 Interfaz: Serial UART para enviarle comandos.

 Quad-band 850/900/1800/1900MHz – se conectan a cualquier red mundial GSM

con cualquier SIM 2G.

 Trabaja solo con tecnología 2G (GPRS).

 Hacer y recibir llamadas de voz usando un auricular o un altavoz externo +

micrófono electret.

 Enviar y recibir mensajes SMS.

 Enviar y recibir datos GPRS (TCP/IP, http, etc).

 Receptor FM.

 Controlado por Comandos AT (3GPP TS 27.007, 27.005 y SIMCOM enhanced AT

Commands) vis UART.

 Interfaz de comandos AT con detección “automática” de velocidad de transmisión.

 Soporta A-GPS (no incluye módulo).

 Datos GPRS: Soporta Reloj en tiempo real (RTC).

 Velocidad máxima de transmisión 85.6 Kbps.

24
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

 Protocolo TCP/IP en chip.

 Velocidades de transmisión serial desde 1200bps hasta 115200bps.

 Tamaño de la SIM: Micro SIM.

2.8. Sistemas Detectores de Intrusos

“IDS es un mecanismo que, sigilosamente, escucha el tráfico en la red para detectar

actividades anormales o sospechosas, y de este modo, reducir el riesgo de intrusión, todo
esto fue detectado mediante la Rasberry pi 3 b+ con un sistema llamado suricata, estos
patrones son conocidos como reglas”.[ CITATION Chr18 \l 9226 ]
Se escogió el sistema suricato, ya que es compatible con el sistema operativo de la Rpi
GNU/Linux para tener las licencias completas.

Ilustración 5. Infraestructura IDS

En la ilustración 5 se aprecia el montaje general del IDS con suricata, un switche, Rpi,
Access point, y dispositivos conectados a la red.

25
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

2.9. Robot Seguidores de línea

“Un robot seguidor de línea solo tiene un objetivo, seguir la línea negra marcada
sobre un tablero blanco.
Lo que debe tener un robot básico [ CITATION Wik12 \l 9226 ]:
 Sensores que detectan la línea.

 Motores que dependen del peso, tamaño, fuerza, entre otros factores para

manejar la potencia y su precisión.

 Ruedas con propiedades antideslizantes.

 Una batería como fuente de alimentación.

 Tarjeta microcontrolador que se va a encargar en la toma de decisiones, tiene

el control de los motores y las señales de los sensores.

EVENTOS DE ROBÓTICA EN COLOMBIA

Algunos de los eventos que investigamos en Colombia son RUNIBOT y ROBOTEX Estos

se describirán a continuación.

RUNIBOT

RUNIBOT – Asociación Red Universitaria Bogotá – Robot. Es una red que agrupa a seis

(6) universidades de Bogotá, interesadas en la investigación y desarrollo de tecnologías

alrededor de la robótica como eje estructurante [ CITATION Run20 \l 22538 ].

La competencia es un reto que prueba las habilidades de dos robots para recorrer la

pista y gana el que recorra el mayor número de ping-pones en un tiempo determinado de

26
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

4 minutos. A continuación, se muestra en la ilustración 6 la pista con cada uno de los ping-

pones en cada determinada distancia.

Ilustración 6. Pista competencia Runibot.

Especificaciones del Robot:

 El robot no debe exceder las dimensiones de 20cm X 20cm, altura libre, no habrá
tolerancia
 No hay restricción de peso.
 El robot deberá ser de tipo autónomo.
 El robot debe tener un switch de encendido y apagado visible y de fácil acceso en
caso de emergencia.
 El robot Deberá poseer una cuenta de tiempo de seguridad de cinco (5)
 segundos, después de activado el robot.

 El robot debe contar con un sistema de recolección y lanzamiento de ping-pones

con pausa y reinicio.

27
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ROBOTEX

“La Universidad Pontificia Bolivariana se prepara para recibir Robotex, el festival de

robótica más grande del mundo, que por segunda ocasión se llevará a cabo en Colombia,

en esta ocasión, del 12 al 15 de junio de 2019”.[ CITATION Red \l 3082 ]

En esta competencia se hace un robot seguidor de línea autónomo, el cual seguirá

una pista trazada que contará con algunos obstáculos. Esta competencia se llevará a cabo

el 29 de noviembre en la UPB.

En la siguiente ilustración se mostrará la pista de la competencia[CITATION rob19 \l

3082 ].

Ilustración 7. Pista Robotex.

Especificaciones de la pista.

 Color de la línea o trayectoria a seguir: Negro

 Ancho de la línea a seguir: 2 cm (20mm) +- 5%

 Color del fondo de la pista: Blanco

28
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

 Material de la pista: Banner

 Longitud aproximada de la trayectoria: 10 – 15 metros

 Señalización: La Pista contendrá una marca donde indicará el inicio y final del

camino.

29
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

3. METODOLOGÍA

En este capítulo se trabaja la información relacionada de cómo fue realizado el

trabajo. Se establece una metodología de trabajo donde se desarrollaron los proyectos

planteados dentro del semillero, y dan solución a los objetivos específicos planteados. Se

detallan los pasos seguidos para la solución de cada proyecto y de esta manera se puedan

replicar dentro de los proyectos del semillero. Los proyectos tratados en este capítulo son

Instalación de Raspbian en la RPi, Manejo de la GPIO con Rpi y Python, Montaje DHT11

Python, Montaje IoT con Rpi y Plataforma AskSensor, Montaje GSM y Rpi, IDS con Suricata

en plataforma IoT RPi, Montaje Robot Seguidor de Línea.

3.1. Instalación de Raspbian en la RPi

Se instalará la imagen de cualquier versión de Raspbian en una micro SD para usarla

en la Raspberry PI. El objetivo será probar si el sistema operativo funciona correctamente

cuando encendamos nuestra tarjeta por primera vez con la SD.

A nivel de hardware para la instalación y comprobación del funcionamiento de

nuestro sistema Raspbian en Raspberry pi será necesario tener:

 x1 Tarjeta micro SD preferiblemente 32GB clase 10 y lector para micro SD

 x1 Raspberry pi (para el ejemplo se usará la versión 3b+)

 x1 Adaptador de corriente 

 x1 Mouse y teclado

30
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

 x1 Cable HDMI y monitor

A nivel de software se requiere:

 Programa SD card formatter

 ISO de Raspbian

 Programa Balena Etcher

Los pasos de Instalación del sistema se describen del ítem 3.1.1. a 3.1.6.

PASOS PARA LA INSTALACIÓN DE RASPBIAN

Paso 1. Instalación de Raspbian:

Inicialmente para descargar la imagen ISO del sistema Raspbian

https://www.raspberrypi.org/downloads/raspbian/[ CITATION Ras19 \l 3082 ] luego

seleccionamos la versión "Raspbian Buster with desktop and recommended software" en

versión .ZIP. En la ilustración 8 se enseña cual iso denemos descargar.

Ilustración 8.Imagen de Rasbian.

31
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Paso 2. Formatear SD Card:

Ahora se formatea la tarjeta micro SD, para el ejemplo se usara una SD clase 10 de

32Gb, será necesario tener el software SD card formatter https://sd-card-

formatter.uptodown.com/windows luego abrimos el archivo comprimido y ejecutamos el

".exe"[ CITATION SDa19 \l 3082 ].

Paso 3. Flasheo con Balena Etcher:

Se descarga el programa Balena Etcher https://www.softpedia.com/get/PORTABLE-

SOFTWARE/CD-DVD-Tools/Etcher-Portable.shtml y se ejecuta para luego montar la

imagen ISO de Raspbian en la SD: [ CITATION Ele18 \l 3082 ]

Se abrirá la interfaz y buscando la imagen del ISO de Raspbian, luego seleccionamos el

micro SD y finalmente se pulsa en "Flash!" como se muestra en ilustración 9.

Ilustración 9. Flash de imagen Rasbian a Micro SD

Una vez el proceso ha terminado saldrá una alerta de que debemos formatear la SD

simplemente se ignorará y cerraremos la pestaña.

32
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Paso 4. Configuración de Rasbian:

Una vez montada la imagen se retira la micro SD del equipo y la insertamos en la

ranura SD de nuestra Raspberry pi encendiendo la tarjeta y si todo sale bien debería iniciar

el sistema:

Luego de un par de minutos finalmente se carga el escritorio de Raspbian.

Finalmente configuraremos nuestro sistema operativo (Wifi, Idioma y otros)

Ilustración 10.Configuración Rasbian

Pulsando en Next en la ventana que se muestra en la ilustración 10, comienza la

configuración del idioma, país y zona, luego cambiamos la contraseña del sistema,

también el screen y la wifi.

33
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Paso 5. Actualización de software Rasbian:

Finalmente preguntará si se desea actualizar el software en Raspbian, no es una

obligación hacerlo, pero sí se hace el proceso puede tardar hasta 1 hora esto no afecta

que queramos hacer otro tipo de tareas en nuestra Raspberry.

Si no se quiere realizar actualización alguna sólo se omite en "Skip" y esto sería todo,

la Raspberry pi está lista para ser trabajada desde el escritorio de la RPi como se muestra

en la ilustración 11.

Ilustración 11. Desktop Sistema Rasbian

3.2. Manejo de la GPIO con Rpi y Python

Se muestra el manejo de la GPIO usando la Rasberry pi 3b+ con el lenguaje Python, se

programará para hacer una secuencia con leds y un pulsador[ CITATION ID19 \l 3082 ]. Lo

primero es instalar el IDLE de Python con el siguiente comando:

sudo apt-get install idle3

Luego descargamos con el siguiente comando las librerías para trabajar de forma

GPIO

sudo apt-get install Python-rpi.gpio Python 3-rpi.gpio

34
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Por último, se crea un archivo en el escritorio de la Rasberry, llamada cont.pin.py,

siempre se debe de guardar con la extensión “. py” para poderlo abrir en Python(idle), y

en el archivo pegamos el código ANEXO1.

En la ilustración 12 se muestran los puertos y conexiones de la Rpi, en este proyecto

conectamos los leds con los pines GPIO 14, 15, 18, 23, 24, 25, 8, 7; conectando estos pines

a cada led para hacer la secuencia y en el GPIO 12 se pondrá el pulsador para salir del

ciclo.

Ilustración 12. Pines de Rpi

En las ilustraciones 13 y 14 se muestran códigos en python, empezando por las

librerías, luego se nombran los pines con los que vamos a trabajar y configuramos los leds

y pulsador como entradas y salidas, se puede visualizar las librerías que se necesitan. En la

ilustración 15 se hace la configuración de los pines GPIO como entradas y salidas y el lazo

infinito hasta presionar el pulsador y saldrá del bucle automáticamente con el break.

Haremos un break para salirnos del bucle cuando detecte que se presionó el pulsador.

35
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 13. Código secuencia de pines 1, Código Anexo 1

36
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 14. Código secuencia de pines 2, Código Anexo

Ilustración 15. Código secuencia de pines 3, Código Anexo 1

Para finalizar se observa el montaje físico de la conexión de la Rpi con leds en la

ilustración 16.

37
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 16. Montaje Físico GPIO

3.3. Montaje DHT11 Python

Para el manejo de las plataformas IoT se hace un diseño por medio de la lectura de un

sensor de Humedad y temperatura con un sensor DHT11 desde la Raspberry pi[CITATION

ID191 \l 3082 ].

Para este proyecto será necesario tener las siguientes herramientas a la mano:

 x1 Raspberry pi (Usaremos la versión 3b+).

 Raspbian montado en micro SD.

 x1 Adaptador de corriente 5v - 2.5A.

 x1 Sensor DHT11 o DHT22.

 x3 Cables jumpers para conexión del sensor a la Raspberry.

 Software IDLE Python 3.0 para programar en dicho lenguaje. 

38
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

3.3.1. Pasos para montar el DHT11 en la RPi con Python

Los tres pasos del montaje se detallan a continuación:

Paso 1. Montaje Rpi y DHT:

En la ilustración 17 se ve el montaje y conexiones de la RPi a una protoboard. Este

será el diagrama de conexión para el sensor DHT11 a la Raspberry pi, Este sensor se

conecta al pin 4, 3.3V, GND.

Ilustración 17. Montaje DHT y Rpi

Paso 2. Instalación de librería DHT desde Git:

Ahora será necesario instalar la librería del sensor para que sea compatible con

Python. Con el siguiente comando:

git clone https://github.com/adafruit/Adafruit_python_DHT.git

Luego con el siguiente comando se dirige a la carpeta descargada con el comando

anterior.

39
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

cd Adafruit_python_DHT

Estando en esta carpeta hacemos el setup necesario para Python.

sudo python3 setup.py install

Paso 2. Comprobación del sensor DHT desde la consola:

Ahora vamos a comprobar que el sensor esté funcionando ejecutando los ejemplos de

Adafruit, escribimos en el terminal:

cd examples

Escribimos el comando para ejecutar el AdafruitDHT.py. Este comando debe

ejecutarse con sudo y “./”, se le adicionan un 11, el cual indica que es el sensor DHT11 y el

4 indica el pin donde se está conectando en la Raspberry, ahora en el terminal se ve en la

ilustración 18 la temperatura y humedad de nuestro sensor con las siguientes variables

Temp y Humidity.

sudo ./AdafruitDHT.py 11 4 

Ilustración 18. Prueba DHT11 y Rpi.

40
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Paso 3. Codificación en Python para leer el sensor desde el Idle

Finalmente se crea un archivo .py desde el idle de Python en el Raspbian, el código

importa la librería de Adafruit y la de time. Toda la lectura va dentro de un bucle infinito

while True, donde el comando de lectura es Adafruit_DHT.read_retry(sensor, pin), la

lectura se hace con un periodo de muestreo de un segundo.

import Adafruit_DHT
import time

while True:
sensor = Adafruit_DHT.DHT11 #Cambia por DHT22 y si usas dicho sensor
pin = 4 #Pin en la raspberry donde conectamos el sensor
humedad, temperatura = Adafruit_DHT.read_retry(sensor, pin)

print ('Humedad: ' , humedad)

print ('Temperatura: ' , temperatura)

time.sleep(1) #Cada segundo se evalúa el sensor

En la ilustración 19 ejecutamos el código y cada segunda muestra los datos de la

lectura del sensor DHT11; a medida que se le aplique calor al sensor, la humedad y la

temperatura aumentan.

41
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 19. Shell de Python 3.7.3, con código DHT.

3.3.2. Alarmas con el DHT11 en la RPi y Python

En la Ilustración 20 se configuran los pines de entrada y salida de la RPi para visualizar

las alarmas por medio de 8 leds, y se define una función Alarma() que prende y apaga los

leds en grupos de cuatro. En la Ilustración 21 muestra el código que activa la alarma

cuando la humedad es mayor a 50.

42
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 20. Código 1 DHT11 + GPIO, Código Anexo 2

Ilustración 21. Código 2 DHT11 + GPIO + Alarmas, Código Anexo 2

En el ANEXO 2 se mostrará la combinación de códigos entre el DHT11 con alarmas

que muestran secuencia de leds (GPIO).

43
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

3.4. Montaje IoT con Rpi y Plataforma AskSensor por medio de

NodeJS

Hardware requerido:

 Raspberry Pi 3 Modelo B

 Micro cable USB para encender tu Pi.

 Tarjeta MicroSD, recomiendo una tarjeta de clase 10 que tenga 16 GB o más.

 Adaptador de tarjeta de memoria MicroSD a SD, necesitará usar el lector de

tarjetas SD en su computadora portátil / computadora de escritorio para

escribir en la tarjeta microSD.

Los pasos a seguir para la implementación de la IoT con askSensors y NodeJS son los

siguientes:

Paso 1. Creación de cuenta en AskSensors:

Se crea una cuenta en la plataforma asksensors: https://asksensors.com/[ CITATION

Ask19 \l 3082 ]. Se crea una cuenta con nuestros datos.

Paso 2. Creación de un nuevo sensor en AskSensors:

Una vez dentro de la aplicación, en el botón naranja “+new sensor” se usa para crear

una nueva lectura de sensor, como se muestra en la ilustración 22.

44
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 22. Creación de nuevo sensor en asksensor.

Ahora aparecerá para crearle el nombre, descripción y un nuevo módulo para la

lectura, al finalizar se presiona guardar (save). Como es un sensor que lee temperatura y

humedad se tiene que crear dos módulos y se crea en el botón “+ add Module”.

Paso 3. Datos necesarios para conexión (APiKey)

Luego, aparecerá los datos de la creación del sensor, tales como el API KEY, fecha de

creación y entre otros, esto se puede visualizar en la ilustración 23.

Ilustración 23. Api Key In

45
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Paso 4. Creación de módulos y gráficos en askSensors:

Por último, en “modules” aparecerá para crear nuevos gráficos.

Cuando se pulsa el botón “+ add graph”, dará la opción de escoger el tipo de grafico

que se desea, se escoge el grafico lineal porque es el más óptimo para nuestra lectura,

cuando se acabe se mostrara el modulo donde se ve los datos, como se ve en la ilustración

24.

Ilustración 24. Gráfico lineal.

Paso 5. Verificación de las versiones de Node JS en la Rpi:

Ahora para asegurarse de que node.js se ejecuta correctamente, se escribe el

comando node -v y npm -v. Este comando debería devolver la versión actual del nodo y

npm instalado. Se asegura de que no dé ningún error. Cabe anotar que el Raspbian

contiene NodeJS dentro de la ISO instalada. Los comandos son:

46
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

node -v

npm -v

Paso 6. Creación del archivo iot.js para ejecución en la Rpi y Asksensors por

medio de NodeJS:

Si después de los comandos node y npm devuelve la versión, se crea un nuevo archivo

llamado iot.js

Ilustración 25. Nuevo archivo iot.js

“Software: dentro del archivo creado se debe añadir el siguiente código .js de github”

[ CITATION Ask192 \l 3082 ]. Para descargarlo se debe ir al siguiente link:

https://asksensors.com/doc/connect-raspberry-pi-https.html

En el ANEXO 3 está el código de iot.js para conectarnos desde la Raspberry pi a la

plataforma asksensors:

Nota: Para no tener ningún problema es mejor tener el archivo en la carpeta pi.

47
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

En la ilustración 25 está el código en el archivo iot.js y se cambiar el API KEY IN para

conectarnos con la plataforma.

Ilustración 26. Código Https, Código Anexo 3

El código se corre con el comando en la consola:

node iot.js

En la plataforma asksensor aparecerá en el módulo, la gráfica que muestra la

conectividad con la Rpi, como se ve en la ilustración 26.

48
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 27. Grafica de muestra HTTPS

Paso 5. IoT con DHT y Node JS:

Se crea otro archivo .js para la lectura de sensor DHT combinado con el código iot.js.
el código está en el ANEXO 4, en las ilustraciones 27 y 28 siguientes, se muestra cómo
debe de quedar el código completo.

Ilustración 28. Código 1 HTTPS + DHT11, Código Anexo 4

49
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 29. Código 2 HTTPS + DHT11, Código Anexo 4

Paso 6. Liberia DHT Node JS:

Antes de ejecutar el código se debe descargar la librería node para la lectura

DHT con el siguiente comando:

npm install node-dht-sensor

Por último, con el comando node DHT.js corremos el programa y leemos el sensor, en
la ilustración 29 se observa los datos del sensor y la conexión con la plataforma
AskSensors.

Ilustración 30. Ejemplos datos de temperatura y humedad

En la ilustración 30 se ve los cambios de la lectura del sensor en la plataforma

asksensors en el cual se ven las variaciones al inducir calor y producir humedad.

50
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 31. Datos transferidos desde las Rpi, Temperatura y Humedad

3.5 Montaje GSM y Rpi

En este proyecto se envían y reciben mensajes de texto por medio del módulo GSM

SIM800L y la Rasberry pi.

El SIM800L está disponible para la transmisión remota de datos de mensajes SMS y

GPRS. Combinando ambos, podríamos controlar diferentes dispositivos a través de la

comunicación de datos GPRS o mensajes de texto.[CITATION Fra181 \l 3082 ]

En este montaje también se usará el modo de transmisión remota de datos de

mensajes SMS SIM800L para controlar tres LED. También se cubre la configuración de la

comunicación en serie para Raspberry pi. El Hardware requerido para hacer el montaje de

la SIM800L es:

51
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

 1 X Raspberry Pi 3 B+
 1 X SIM800L con TARJETA SIM
 3 X LED
 Resistencia 3 X 1 k
 1 X placa sin soldadura
 7 X cables de conexión macho a hembra
 1 X cables de conexión macho a macho

A continuación, en la ilustración 31, se ve la conexión del módulo GSM con la

Rasberry por medio de comunicación serial:

Ilustración 32. Conexión Sim800l y Rpi

CONFIGURACIÓN DEL MODULO SIM800L CON RPi y Python y picocom

Paso 1. Actualización repositorios y paquetes:

Lo primero que debemos hacer es asegurarnos de que todos los componentes de

software estén actualizados.

Actualice el repositorio y actualice los paquetes instalados:

sudo apt-get update

sudo apt-get upgrade -y

52
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Actualiza el firmware:

sudo rpi-update

Reiniciar para aplicar los cambios:

Sudo reboot

Habilitar UART

Raspberry Pi 3 en comparación con Raspberry pi anterior se comporta de manera

diferente con respecto a la interfaz UART en el encabezado GPIO, por eso se necesita

habilitarlo primero.

Habilitación de UART con frecuencia de núcleo mínima:

sudo nano /boot/config.txt

Agregue esta línea al final como se ve en la ilustración 32;

core_freq=250

# Habilitar UART

enable_uart = 1

53
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 33. Configuración UART Rpi

En caso de que desee conectar un HAT usando la interfaz UART, se recomienda

deshabilitar la consola.

Para deshabilitar la consola, editar el siguiente archivo de la siguiente manera:

sudo nano /boot/cmdline.txt 

Se verá algo como:

console = serial0,115200 console = tty1 root = / dev / mmcblk0p2 rootfstype = ext4

elevator = deadline fsck.repair = yes rootwait

Eliminar la línea:  console = serial0,115200 y guardar, debe de quedar como se ve en

la ilustración 33.

 Reiniciar para aplicar los cambios:

Sudo reboot

54
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 34. Deshabilitar UART

Por último, se hace una configuración para el puerto serie para Python:

Poner en la terminal el comando:

dmesg | grep tty

Esta instrucción permite ver los puertos seriales conectados.

Una vez verificados los puertos a configurar, la Raspberry con Linux no use la

UART para login Shell, para ello en la consola de comandos se digita:

sudo raspi-config

Con esta instrucción se abre el software de configuración general de la tarjeta, en la

opción 5 de opciones de interfaz, posteriormente se inhabilitará el login Shell, pero se
mantendrá habilitado el Hardware de la UART.

Se hace el paso a paso de las siguientes ilustraciones 34-38.

Ilustración 35.Opciones de Interfaz

55
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 36. Serial

Ilustración 37. No al login Shell

Ilustración 38. Habilitar el puerto serial hardware.

56
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 39. Reiniciar.

Una vez hecho el ajuste, salir del raspi-config y reiniciar la tarjeta para confirmar que

se hizo correctamente el cambio mientras inicia la tarjeta no volverá a enviar datos por la

UART.

Si todo fue correctamente configurado se podrá enviar información de forma

bidireccional ya sea para enviar o recibir datos.

Paso 2. Aplicación Picocom descarga y configuración con comandos AT:

Ahora se descarga una aplicación llamada picocom, que es un programa emulado

donde le se puede varios comandos AT para comunicarnos con el módulo GSM, el

comando para descargar picocom es el siguiente:

sudo apt-get install picocom

cuando finalice de instalar, digitar el siguiente comando para abrir picocom:

picocom --baud 115200 /dev/ttyS0

Cuando se ejecute debe de aparecer algo como se ve en la ilustración 39.

57
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 40. Picocom

a. AT, cuando se pone el comando at devolverá un OK para saber si hay

comunicación serial entre el módulo GSM y la Rasberry pi
b. Devolverá automáticamente unos comandos +CPIN: READY, CALL READY, MSN
READY; cuando el módulo coja señal y conecte con el servidor de la simcard y
operador que tenga. se sabrá que tiene señal cuando el led intermitente prenda y
apague alrededor de 5 segundos)
c. El comando para llamar es: ATD31223420; atd más el número de celular que
queremos llamar más punto y coma.
d. Para recibir llamadas en picocom aparece el comando RING más el número de
contacto que te está llamando.
e. Para enviar un mensaje de texto: AT+CMGF=1 y se devuelve un ok, luego:
AT+CMGS="+573010000000" (remplaza el numero al que quieres enviar el
mensaje), después el sistema responde: > (aquí va el mensaje que quieres enviar)
al final el mensaje finalizarlo con *
f. Ahora para leer un mensaje de texto: con el siguiente comando; AT+CMGF=1 y el
sistema responde con un ok, después escribimos AT+CMGL="ALL" y se reflejara el
listado de los mensajes de texto.

58
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Códigos En Python para enviar y recibir llamadas con la SIM800L y

guardar en un log:

En este espacio mostrare los códigos para enviar y recibir llamadas y mensajes de
texto con códigos Python.

a. El código de la ilustración 40 es para enviar mensajes de texto.

Ilustración 41, código enviar msm, código ANEXO 5

59
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Los pasos para implementar la SIM800L con un log son:

b. Aquí se hace un registro de mensajes en .log como se ve en la ilustración 41

(para después combinar el código de enviar mensaje de texto para solo
enviar el último mensaje del registro).

Ilustración 42, código .log, código ANEXO 6

c. Código combinado ilustración 42: apena se ejecute el código en Python

envía automáticamente el último mensaje del registro creado en .log, (el
archivo .log se puede crear directamente del desktop de la Rasberry).

60
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 43. Enviar mensaje con .log, ANEXO 7

d. Código para hacer llamadas en la ilustración 43:

Ilustración 44. Código para enviar llamadas, Código ANEXO 8

61
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

e. Por último, se mostrará un código combinando todo lo aprendido

anteriormente encendiendo y apagando 3 leds enviando mensajes de texto,
en las ilustraciones 44 y 45.

62
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 45. Código 1 enviar msm para encender leds, Código ANEXO 9

63
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 46. Código 2 enviar msm para encender leds, Código ANEXO 9

f. Cuando está en modo escucha de mensajes llegaron tus mensajes de texto

automáticamente.

64
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

3.6. IDS CON SURICATA EN PLATAFORMA IoT RASPBERRY

Usando la tarjeta Raspberry Pi en su versión 3B+, se implementará un sistema de

detección de intrusos conocido como IDS, en una red de área local u hogar, esto con el

propósito de emular el mismo producto empresarial/Industrial que existe en sistemas IDS

cuyo costo es extremadamente elevado, a cambio con Raspberry y algunos componentes

extra se podrá filtrar y ver el tráfico que pasa por la red, en la ilustración 46 se verá el

plano de conectividad.

Ilustración 47. Gráfico IDS

¿Qué se necesitará?

Entre la lista de elementos a usar se tiene:

- X1 Raspberry Pi 3B+
- X1 Cable de alimentación para raspberry
- X1 Switch Cisco (O cualquier otro que acepte Port Mirroring)
- X1 Router Tp-link o el de uso casero en el hogar es válido
- X1 Access Point
- Cables UTP para realizar conexiones
- Celulares o PCs que servirán como clientes en la red.
- Software Putty para configuración del Switch Cisco
- Software Suricata
- Sistema Operativo Raspbian en tarjeta micro SD de 32Gb clase 10

65
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Paso 1. Instalación y configuración:

Como primer paso se hará el montaje físico de la red, tal y como se aprecia en la

imagen anterior, en este caso se ha emulado todo el proyecto en un laboratorio de redes

por facilidad en el uso de distintos equipos, pero muchos de ellos fáciles de adquirir en el

mercado a nivel global: Veremos los componentes que usaremos para montar el IDS.

Ilustración 48. Componentes usados para IDS.

Paso 2. Instalación de suricata en Rpi y Configuración con comandos :

Existen varias maneras para instalar Suricata, en este caso se ejecutará desde el

LXTerminal de Raspbian la siguiente lista de comandos para configurar el sistema

operativo y dar compatibilidad al software, se creará un nuevo usuario reemplazando

“yeknu” por el nuestro de usuario que tenga Raspbian en ese momento:

66
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 49. Creación de nuevo usuario.

Se borrará el usuario PI, se debe salir de la sesión y entrar con el nuevo usuario

creado:

Ilustración 50. Eliminar usuario pi

Se habilitará SSH para ejecutar durante el arranque del servicio:

Ilustración 51. Habilitar SSH

Es importante habilitar el modo promiscuo en la Raspberry pi para que capture y

comparta el tráfico que reciba por las diferentes interfaces en el switch (Que tendrá

configurado port mirroring ya sea de forma manual o por defecto):

Ilustración 52. Modo promiscuo

67
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Se inicia el proceso de instalación de Suricata con el siguiente comando y así habilitar

el arranque automático:

Ilustración 53. Instalación de suricata

Con Suricata ya instalado, lo siguiente será actualizar las reglas periódicamente

ejecutando lo siguiente:

Ilustración 54. Actualización de reglas

Se busca en el directorio /etc/suricata/rules/ allí el paquete de reglas siempre

mantendrá actualizado, ahora se añaden dos tareas con crontab:

Ilustración 55. Tareas contab

Hasta aquí Suricata correrá de forma autónoma cada que se inicie Raspbian.

Paso 3. Habilitacion “Port Mirroring” en Switch de cisco.

Ahora será necesario habilitar Port mirroring, esto es una función que tiene el switch

para capturar todo el tráfico de una interfaz específica a otra interfaz es decir replicar

68
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

todo lo que por allí se transmite, trabajo que termina Suricata al mostrar este tráfico al

analista.

Lo primero por tener en cuenta es el puerto origen. Debe ser el puerto al cual se le

analizará el tráfico en este caso el cable UTP/Ethernet del cual estará conectados todos los

equipos y router:

interface GigabitEthernet1/10

description *** Origen Port Mirroring ***

switchport

switchport access vlan 100

switchport mode access

switchport nonegotiate

spanning-tree portfast

spanning-tree bpduguard enable

spanning-tree guard root

end

A continuación, se configura el puerto desde el cual se analiza el tráfico es decir

donde está conectada la tarjeta Raspberry PI que será el analizador de red:

interface GigabitEthernet2/10

description *** Destino Port Mirroring ***

69
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

switchport

switchport access vlan 100

switchport mode access

switchport nonegotiate

spanning-tree portfast

spanning-tree bpduguard enable

spanning-tree guard root

end

Ingresando en modo “enable” para hacer las siguientes configuraciones también se

habilita el comando “config t”:

Switch 1 # enable

Switch 1 #config t

Y se configura el puerto de origen es decir los equipos a analizar:

Switch 1 (config)#monitor session 1 source interface gigabitEthernet 1/10

Switch 1 (config)#

Ahora se realiza el mismo procedimiento para con el puerto destino es decir la

raspberry pi:

Switch 1 (config)#monitor session 1 destination interface gigabitEthernet 2/10

70
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Switch 1 (config)#

Finalmente se comprueba que el “port mirronring” esté operativo con el siguiente

comando:

Switch 1 #

show monitor detail

Session 1

———

Type : Local Session

Description :–

Source Ports : Gi1/10

RX Only : None

TX Only : None

Both : Gi1/10

Source VLANs :

RX Only : None

TX Only : None

Both : None

Source RSPAN VLAN : None

Destination Ports : Gi2/10

71
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Filter VLANs : None

Dest RSPAN VLAN : None

Source IP Address : None

Source IP VRF : None

Source ERSPAN ID : None

Destination IP Address : None

Destination IP VRF : None

Destination ERSPAN ID : None

Origin IP Address : None

IP QOS PREC :0

IP TTL : 255

Switch 1 #

La configuración está correcta.

Paso 4. Ejecución de suricata en Rpi y sus reglas personalizadas:

A continuación, se ejecutará Suricata para comprobar su funcionamiento y capturar el

tráfico en la red local instalada, esto significa configurar el IDS en Raspberry como

dispositivo IoT para que genera alertas.

72
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Se configurará otra tarjeta de Red USB en Raspbian para tener dos en total, ambas

acordes a la VLAN establecida en la configuración del switch en este caso siendo la VLAN

100 tomando como ejemplo para el equipo atacante:

iface eth0 inet static

address 172.16.0.2

netmask 255.255.255.0

network 172.16.0.0

gateway 172.16.0.1

Al tener habilitadas dos tarjetas de red es necesario activar y configurar

IP_FORWARDING para que los paquetes pasen de la Raspberry hacia el o los equipos a

proteger y viceversa, se requiere ejecutar la siguiente línea de comandos para:

echo 1 > /proc/sys/net/ipv4/ip_forward

iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

iptables -t nat -A POSTROUTING -o eth1 -j MASQUERADE

iptables -A FORWARD -i eth0 -o eth1 -m state --state RELATED,ESTABLISHED -j ACCEPT

iptables -A FORWARD -i eth1 -o eth0 -m state --state RELATED,ESTABLISHED -j ACCEPT

iptables -A FORWARD -i eth1 -o eth0 -j ACCEPT

iptables -A FORWARD -i eth0 -o eth1 -j ACCEPT

Y se verifica las reglas anteriormente puestas con el comando “iptables -vnL”:

73
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 56. Verificación de reglas

Y en color amarillo a la derecha se puede verificar que las reglas han sido establecidas

para ambas tarjetas de red en la Raspberry Pi para establecer comunicación del tráfico

entre la eth1 hacia eth0 y viceversa.

Por lo cual la máquina atacante podrá hacer ping hacia el IPS (192.168.1.100) como se

verá en la siguiente imagen:

Ilustración 57. Ping de la maquina atacante

Ahora desde el LXTerminal se ejecutará el comando “suricata --build-info” para

verificar que esté activo los servicios de “AF_PACKET support” y “NFQueue support”:

Ilustración 58. Servicios AF y NF

74
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Resaltado en Rojo los servicios buscados, ahora se agregará la siguiente configuración

de red al archivo setup de Suricata:

HOME_NET: “[192.168.0.0/24]”

EXTERNAL_NET: “[172.16.0.0/24]”

Visto de la siguiente manera directamente en el archivo:

Ilustración 59. Configuración home y external

Finalmente se reinicia Suricata para predeterminar todos los cambios que se han

hecho, para ello se lanza el siguiente comando “/etc/init.d/suricata restart”, luego al

firewall se le establecerá las siguientes reglas:

iptables -I FORWARD -i eth0 -o eth1 -j NFQUEUE

iptables -I FORWARD -i eth1 -o eth0 -j NFQUEUE

75
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Comprobándolas desde LXTerminal así se observa como ambas interfaces escuchan

todo el tráfico proveniente de cualquier red al tener como origen y destino 0.0.0.0/0:

Ilustración 60 Interfaces con todo el trafico

Paso 5. Capturando tráfico de la Red:

Configurado el setup y sus reglas, y las reglas del Firewall para analizar información se

procede a ejecutar pings o peticiones entre máquinas para que desde la Raspberry PI y en

su consola se pueda ver que comportamiento hay, es decir se verificarán las reglas

impuestas en ese tipo de peticiones, agregando en el archivo custom.rules ciertas reglas

personalizadas para efectos de prueba “pass icmp $EXTERNAL_NET any -> any any (msg:

"ICMP detected desde afuera";)”

Ilustración 61. Custom.rules

Para culminar se escribe el comando “suricata -q 0” para escanear el tráfico en red,

obteniendo en el LOG del script lo siguiente:

76
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 62. Escaneo de tráfico de la red

Donde se detectan peticiones ICMP,WEB en distinto horario, siendo la última

catalogada como una posible petición de ataque desde un aplicativo web, es posible

obtener otros resultados en el log según las reglas impuestas en el custom.rules como SSH

y HTTPS pero esto varía según las peticiones que hagan las máquinas conectadas en red

local, sin embargo Suricata siempre estará activa vigilando esta información.

3.7 Montaje Robot Seguidor De Línea

Usando los conocimientos en robótica se diseñará un robot seguidor de línea para

competiciones a nivel nacional, el mismo fue mostrado en la semana de ingeniería (SII) de

la universidad ITM, este producto se acopla a las necesidades del departamento de

electrónica y telecomunicaciones. Se ha desarrollado para incentivar a estudiantes de

electrónica a adquirir experiencia en el diseño de este tipo de robots siendo el principal

objetivo el entendimiento de su funcionamiento y ver la relación con el programa de

tecnología e ingeniería en electrónica.

77
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Tabla 4. Partes y costos

Parte/Componente Cantidad Precio Precio
por unidad parcial
Turbina DF150 RC 1 $150.000 $150.000
Ruedas adherentes azules 2 $10.000 $20.000
Rines de aluminio hechos en 2 $10.000 $20.000
torno
Regleta 16 sensores análoga 1 $110.000 $110.000
DSPIC 30F4011 Superficial 1 $15.000 $15.000
Batería LiPo 8.4V 500mAh 1 $40.000 $40.000
Driver para turbina DF150 RC 1 $60.000 $60.000
Chasis (Circuito impreso) 1 $60.000 $60.000
Elevadores de corriente Pololu 2 $10.000 $20.000
Micromotores Pololu 10:1 2 $55.000 $110.000
3000rpm
Condensadores Varios $3.000 $3.000
Leds SMD Varios $10.000 $10.000
Cable tipo bus de datos 1 $10.500 $10.500
Conexiones tipo hembra Varios $2.000 $2.000
Trimer 1 $1.500 $1.500
Tornillos y tuercas Varios $5.000 $5.000
Puente H LD298 superficial 1 $28.000 $28.000
Programador de PIC 1 $50.000 $50.000
Cargador batería LiPo, 1 $200.000 $200.000
profesional
Total: $914.000

Costos y presupuestos

En la tabla 4 partes y costos para mostrar que el dinero es un factor clave en el

desarrollo de este tipo de proyectos pues ha sido un seguidor de línea de para

competencias de alto rendimiento en el listado de ¿Qué necesita? Se tiene al frente de

cada componente el costo por unidad, obteniendo una inversión total ideal de $914.000

pesos colombianos, sin tener en cuenta el tiempo establecido y algunos errores que se

cometieron implicaba reemplazar una pieza importante del robot.

78
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ACERCA DEL ROBOT Y SUS CARACTERÍSTICAS

El diseño de seguidores de línea no posee un estándar completo además de la

relación peso/potencia para ganar velocidad y mejoras en otras variables físicas, es por

ello que como incentivo para la SII (Semana de la Ingeniería) se desea mostrar un seguidor

de línea de alto rendimiento capaz de recorrer la pista estándar del ITM en menos de 6

segundos, todo esto llevando una línea de desarrollo desde el montaje superficial hasta el

tipo de ruedas usadas.

Escogiendo el microcontrolador

Existen múltiples microcontroladores de alto rendimiento en temas relacionados con

robótica de competencia, considerando factores importantes como costo vs calidad al

menos en Colombia los más usados actualmente son Arduino en sus versiones Nano y

mini y la tarjeta de Pololu Baby Orangutan, sin embargo, al no cumplir con los requisitos

respecto a tamaño y peso se decide usar un microcontrolador avanzado dsPIC 30F4011

entre sus principales características y ventajas se tiene señales de 16 bits, memoria flash

de 48kB, memoria RAM de 2048 Bytes, EEPROM de datos de 1024 Bytes, velocidad de CPU

hasta 30MIPS y 30 fuentes de interrupciones siendo este uno de sus mejores aspectos,

además su precio oscilo entre los $9.000 a $16.000 frente a $30.000 o más del precio de

otros micros.

79
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 63. Dspic 30f4011

Diseño de chasis y montaje superficial

En algunos seguidores se ensambla por separado el chasis y el montaje del circuito de

este, sin embargo, existen opciones que demandan cierta dificultad, pero óptimas para el

peso del robot, así que se escogió diseñar un circuito con tecnología de montaje

superficial siendo este a la vez el chasis del robot en su diseño final su peso total es de 164

gramos como se ve en la siguiente imagen:

80
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 64. Peso del robot

A continuación, se profundizará en el diseño del montaje superficial, creado con el

software Proteus y Proteus PCB se puede ver en la siguiente imagen de forma general el

Chasis creado

Ilustración 65. PCB chasis del robot

81
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Regleta de 16 sensores

El seguidor de línea usa una regleta de 16 sensores en línea con referencia exacta

QTR-8A, cuya labor es detectar la cantidad de luz reflejada en una superficie, midiendo la

longitud del pulso de luz se sabe cuánto está reflejando el sensor, en la ilustración 66 se ve

el circuito que tiene el robot de cada uno de los sensores.

En el caso de que la salida sea analógica como para este caso, será necesario usar un

conversor A/D (analógica a digital). Dichas señales obtenidas pasarán por un multiplexor

que comunicará por el cable tipo bus de datos al microcontrolador que comportamiento

deben tomar los motores respecto a aumentar, sostener o disminuir la velocidad.

Ilustración 66. Circuito de Sensor

motores

Se han usado dos motores de la marca Pololu, cuya relación de engranajes es 10:1, con un
voltaje nominal de 6 voltios, alcanzando puestas en marcha de 3000 revoluciones por
minuto, 120mA sin carga y 0.3Kg*cm total de torque, catalogados y avalados para
competencias de alto nivel en Colombia.

Se debe entender que si ambos motores funcionan a las mismas RPM a la vez el robot
debe ir en línea recta y variando las RPM de uno y otro se conseguirá que gire ya sea a la
izquierda o la derecha, a esto se le llama configuración diferencial y es el mecanismo
utilizado en muchas máquinas industriales en la actualidad. Respecto al controlador
82
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

proporcional el robot posee una regleta de 16 sensores en línea con una separación de 0.4
centímetros, así se detecta la posición de la línea con una precisión de 0.4cm, si la línea se
mueve habrá un error positivo o negativo según hacia donde sea el desplazamiento.   

El código para el robot seguidor de línea ha sido desarrollado en lenguaje C entre sus
partes más importantes se resaltan el movimiento de los motores con solo agregar algún
valor numérico entre 0 y 10000 para el PWM:
/----------- Motores---------/
int16 UL=000;    // Velocidad de motor Izquierdo [0 1]
int16 UR=000;    // Velocidad de motor Derecho [0 1]
int16 PWM_max=10000;      // Máximo valor posible de PWM
int16 PWM_min=-10000;    // Mínimo valor posible de PWM
 
 

La función a cargo de calibrar los sensores y establecer los valores leídos para
reescribirlos en el momento de correr:
void Calibrar_sensores() {
                                int8 Columna,fila;                                     
                                float SetP=400.0;
                                float valor=0.0;
                                float valor2=0.0;
                                int16 i=0;
                                int8 x=0;
                                int8 y=0;
                                float vsensor = 0.0;                 
 
                                while(1){
                                valor=Sensores(0);
                                valor2=Sensores(15);
                                if(valor>Setp && valor2>Setp){
                                                              for(y=0;y<25;y++){
                                                              for(x=0;x<16;x++){
                                                                                              //                        delay_ms(10);
                                                                                              for(i=0;i<100;i++){
                                              
                                                                                                                              vsensor = Sensores(x);
                                                                                                                              if(vsensor>Max[x]){
                                                                                                                                                              Max[x] = vsensor;
                                                                               }
 
                                                                                                                              if(vsensor<Min[x] && vsensor!=1023.0){
                                                                                                                                                              Min[x] = vsensor;

83
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

                                                                                                                                                              }                         
                                                       }

Dichos valores son almacenas en un vector que ya está definido dentro de la función.

Proteus

A nivel de diseño de componentes y lógica programada del circuito del seguidor de

línea se puede ver el siguiente CAD creado:

Ilustración 67. Montaje en Proteus

Esta ilustración se ve mejor en el ANEXO 11

Programando el Seguidor de Línea y su código con control PD

Usando lenguaje C con algunas rutinas, investigando se determinó que el robot usaría

un controlador PD porque es un elemento de transferencia donde el componente

diferencial responde a la velocidad en la que el error de control cambia, este valor es

multiplicado con el coeficiente de acción derivativa y se suma el componente P lo que por

su parte, actúa proporcionalmente en un error de control específico, el controlador PD

puede responder a un error de control inminente y por lo tanto, lograr una acción

84
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

derivada durante el proceso de control ya que se necesitan cambios bruscos en la lectura

de los sensores para que el robot siga la línea y obtenga la estabilidad deseada para

establecer el mejor rendimiento en la pista.

Pruebas y pista de competencia

La pista de competencia en la semana de la Ingeniería ha sido la siguiente:

85
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Ilustración 68. Pista de competencia semana de la ingenieria

Estableciendo 4 curvas cerradas lo que apoya el uso de un controlador PD en el robot,

en el siguiente link se podrá observar un vídeo del robot corriendo:

https://youtu.be/AYdWramNjmQ, La pista tiene unas dimensiones rectangulares

aproximadas de 2 metros x 1 metro.

El código está en el ANEXO 10.

4. RESULTADOS Y DISCUSIÓN

86
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

En este trabajo se logró resolver cada uno de los retos y problemas que habían

propuestos, uno de los aspectos más relevantes es la actualización de información, porque

en trabajos similares que hay en internet todos son muy antiguos, ya que cada día la

tecnología se actualiza constantemente y siguiendo pasos de estos trabajos hay informes

que no resuelven nada o no funcionan, pero acumulando e investigando más afondo se

logró cumplir los resultados que se querían.

Una de las mayores fortalezas fue el amplio conocimiento que se obtuvo en la

investigación del MiniPc Rasberry pi, porque hay demasiada información de este para

lograr mis objetivos; uno de ellas fue una página llamada innovadomotics donde me

ayudo a adquirir conocimientos de este microcontrolador por medio de documentaciones

y videos, este tiene un curso hablado del microcontrolador alrededor de 11 videos

explicando gran parte del producto enseñando lo básico de GPIO y lectura de sensor

DHT11 en Python.

Ilustración 69. Curso de InnovaDomotic

Una de las mayores dificultades estuvo en la parte del proyecto gsm, en el que se tuvo

que innovar; se probó cosas nuevas saliéndose de lo que hay en internet, porque no
87
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

funciona muy bien, al final se pudo resolver el problema enviando y recibiendo llamadas y

mensajes de texto como se ve en la ilustración 70, Otra dificultad fue que el módulo

Sim800l no conectaba al servidor del operador, porque la configuración de la Rpi no tenía

deshabilitada los puertos UART, lo anterior se resolvió configurando la Rpi deshabilitando

su bluetooth con puerto serial TTYAMA y habilitando el puerto de paso bidireccional de

datos UART ttyS0, por esto en la ilustración 71 se visualiza los puertos que hay que

habilitar y deshabilitar.

Ilustración 70. Prueba llamada comando AT

Ilustración 71. Puertos UART

En el proyecto de la lectura de sensor dht11 con el lenguaje de programación

javascript se tuvo algo de dificultad en la parte de combinar el código de lectura con el

88
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

sensor y el código de comunicación con la plataforma ask sensor mostrando error en la

consola como se muestra en la ilustración 70, al final se resolvió intentando leer la

humedad y la temperatura por separado, porque los datos no transferían en conjunto a la

plataforma y toco separarla.

Ilustración 72. Erros al ejecutar el codigo

Por último, el informe con suricata se tuvo algunos inconvenientes con la

actualización de las reglas para comunicar los dispositivos y la rasberry pi como IDS, pero

al final se resolvió haciendo el forward para que los paquetes pasen de la Raspberry hacia

el o los equipos a proteger y viceversa, con el resultado de el escaneo de trafico de red.

Ilustración 73. Resultado de trafico de web.

89
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

5. CONCLUSIONES, RECOMENDACIONES Y
TRABAJO FUTURO

Teniendo en cuenta el auge que está tomando hoy en día el mundo digital, el internet

de las cosas, blockchain, entre otras temáticas que tienen que ver con el manejo de datos

desde una nube, este proyecto es un mediador entre las personas y el internet de las

cosas implementando esta nueva tecnología en sus vidas cotidianas, haciendo de éstas

más fáciles y llevaderas en cuanto a temas de guardar información se trata.

Una conclusión importante de este proyecto es como la seguridad digital se vuelve un

foco importante, que nos permite igualmente proteger nuestros dispositivos con sistemas

de detección intrusos con acceso no autorizados a un dispositivo o a una red se vuelve en

reto.

Es entonces, cuando comprendemos la magnitud de un mundo globalizado

tecnológicamente y de qué manera positiva influye en la calidad de vida de las personas

que lo utilizan, que tanto avance proporcionan a la actualidad, y que tanto estamos

preparados tecnológica y culturalmente para hacer parte de este cambio e innovación en

nuestro diario vivir.

90
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Se cumplieron los objetivos en este proyecto, encaminados a compilar la mayor

información posible, análisis investigativo, con el fin de exponer un material completo y

acertado en el tema de la programación.

Una de las conclusiones más detallada, es la descripción del ras Berry PI, ya que es un

dispositivo muy pequeño que brinda un amplio número de lenguajes de programación,

gracias a esto se logró llevar a cabo este proyecto de medición y temperatura del aire.

En esta investigación hemos indagado sobre la aplicación de una herramienta

tecnológica, recurso que juega un papel más preponderante en la actualidad. La puesta en

práctica de nuevas Tecnologías de información, especialmente el uso que se le da para el

aprovechamiento y desarrollo a la actualidad.

La información recopilada mediante la aplicación de las diferentes programaciones,

sumado con la observación como factor clave en la realización de este proyecto, me

permitió establecer una imagen de la relación de los factores de impacto tecnológico.

Esta implementación fue posible gracias a los aportes de conceptos informáticos que

hicieron parte de la investigación de objetos virtuales, diseñados para un propósito de

desarrollo y avance tecnológico.

91
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

REFERENCIAS

Aguerreberry, D. (24 de Septiembre de 2018). Rasberry para torpes . Obtenido de

https://raspberryparatorpes.net/rivales/raspberry-pi-vuelve-a-ser-la-mejor-placa-

de-2018/

Ask Sensors. (2019). Obtenido de https://github.com/asksensors/AskSensors-node.js-

API/blob/master/https_get.js

Ask Sensors. (2019). Obtenido de https://asksensors.com/doc/connect-raspberry-pi-

https.html

AskSensors. (2019). AskSensors. Obtenido de https://asksensors.com/doc/connect-

raspberry-pi-https.html

association, S. (2019). sd-card-formatter. Obtenido de uptodown: https://sd-card-

formatter.uptodown.com/windows

Ato. (2019). Automation Technologies Online. Obtenido de

https://www.ato.com/temperature-and-humidity-sensor-dht11

Blancarte, O. (2017). Introducción a NodeJS. Obtenido de

https://www.oscarblancarteblog.com/2017/05/29/introduccion-a-nodejs-2/

db, b. (s.f.). Raspberry Pi 3 Model B vs. Orange Pi Mini 2 vs. Orange Pi Plus 2E vs.

BeagleBone Black Rev. C. Obtenido de

https://www.hackerboards.com/compare/103,50,113,7/

92
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Domingo, C. (19 de Febrero de 2018). sothis. Obtenido de

https://www.sothis.tech/detectando-intrusos-casa-parte-i/

Domotics, I. (2019). Obtenido de https://www.youtube.com/watch?

v=naC0lIuHWAc&list=PLZHVfZzF2DYIa1Orv3gro4rW9jFedPR96&index=8

Francesc. (2018). Obtenido de http://fpaez.com/llamadas-y-sms-usando-un-modulo-

sim900-y-raspberry-pi/

Francesc. (19 de Septiembre de 2018). fpaez.com. Obtenido de

http://fpaez.com/llamadas-y-sms-usando-un-modulo-sim900-y-raspberry-pi/

I.D. (11 de Marzo de 2019). innova domotics. Obtenido de

https://www.youtube.com/watch?v=W-

NzzjQD80k&list=PLZHVfZzF2DYIa1Orv3gro4rW9jFedPR96&index=5

node.js. (2019). node js. Obtenido de https://nodejs.org/es/about/

omniblug. (2019). Omniblug dht. Obtenido de http://www.omniblug.com/sensor-

temperatura-humedad-DHT11-DHT22.html

Opris, E. (2018). softpedia. Obtenido de https://www.softpedia.com/get/PORTABLE-

SOFTWARE/CD-DVD-Tools/Etcher-Portable.shtml

Python. (2019). Python tutorial. Obtenido de

https://docs.python.org/3/tutorial/index.html

Rasbian. (2019). Rasberrypi.org. Obtenido de

https://www.raspberrypi.org/downloads/raspbian/

93
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Redmas. (s.f.). Redmas. Obtenido de Robotex:

http://www.redmas.com.co/tecnologia/robotex-festival-robotica-llega-colombia/

robomatrix. (2019). Obtenido de http://robomatrix.org/wp-

content/uploads/2012/09/seguidor.pdf

Runibot. (2020). Runibot. Obtenido de https://www.runibot.com/reglamento

RutaN. (2019). Industrias 4.0. Obtenido de https://www.rutanmedellin.org//es/industria-

4-0/item/4revolucion-internet-de-las-cosas

Sum, E. (2019). Programo Ergo Sum. Obtenido de

https://www.programoergosum.com/cursos-online/raspberry-pi/232-curso-de-

introduccion-a-raspberry-pi/instalar-raspbian

Velasco, R. (12 de Abril de 2017). Raspberry Pi 3 vs Orange Pi Prime ¿Cuál es mejor?

Obtenido de Redes Zone: https://www.redeszone.net/2017/04/12/raspberry-pi-3-

vs-orange-pi-prime/

Velasco, R. (02 de Julio de 2018). Hardzone. Obtenido de

https://hardzone.es/2018/07/02/review-raspberry-pi-3-modelo-b/

Wikipedia. (04 de Mayo de 2012). Wikipedia. Obtenido de

https://es.wikipedia.org/wiki/Robot_seguidor_de_l%C3%ADnea

wikipedia. (2019). Obtenido de https://es.wikipedia.org/wiki/VNC

94
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ANEXOS

ANEXO 1
#importamos la libreria y cambiamos su nombre por "GPIO"
import RPi.GPIO as GPIO
#necesario para los delays
import time
#establecemos el sistema de numeracion que queramos, en mi caso BCM
GPIO.setmode(GPIO.BCM)
#definimos los pines gpio
Led_1 = 14
Led_2 = 15
Led_3 = 18
Led_4 = 23
Led_5 = 24
Led_6 = 25

Led_7 = 8
Led_8 = 7
Pulsador = 12

#configuramos el pin GPIO como salida y entrada

GPIO.setup(Led_1, GPIO.OUT)
GPIO.setup(Led_2, GPIO.OUT)
GPIO.setup(Led_3, GPIO.OUT)
GPIO.setup(Led_4, GPIO.OUT)
GPIO.setup(Led_5, GPIO.OUT)
GPIO.setup(Led_6, GPIO.OUT)
GPIO.setup(Led_7, GPIO.OUT)
GPIO.setup(Led_8, GPIO.OUT)
GPIO.setup(Pulsador, GPIO.IN)

while True: #Ingresamos a un lazo infinito

# -------- LAZO INFINITO --------
GPIO.output(Led_1, GPIO.HIGH)
GPIO.output(Led_2, GPIO.HIGH)
GPIO.output(Led_3, GPIO.HIGH)
GPIO.output(Led_4, GPIO.HIGH)
GPIO.output(Led_5, GPIO.HIGH)
GPIO.output(Led_6, GPIO.HIGH)
GPIO.output(Led_7, GPIO.HIGH)
GPIO.output(Led_8, GPIO.HIGH)
time.sleep(0.5)

GPIO.output(Led_1, GPIO.LOW)
GPIO.output(Led_2, GPIO.LOW)
GPIO.output(Led_3, GPIO.LOW)
GPIO.output(Led_4, GPIO.LOW)
GPIO.output(Led_5, GPIO.LOW)
GPIO.output(Led_6, GPIO.LOW)
GPIO.output(Led_7, GPIO.LOW)
GPIO.output(Led_8, GPIO.LOW)
time.sleep(0.5)

95
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

print ("LAZO LOOP")

i = GPIO.input(Pulsador)

#----------------------------------------
if i==0:
#--------------------------------------
for c in range(2):
#------------------------------------
for c in range(8):
#----------------------------------
GPIO.output(Led_1, GPIO.LOW)
GPIO.output(Led_2, GPIO.LOW)
GPIO.output(Led_3, GPIO.LOW)
GPIO.output(Led_4, GPIO.LOW)
GPIO.output(Led_5, GPIO.LOW)
GPIO.output(Led_6, GPIO.LOW)
GPIO.output(Led_7, GPIO.LOW)
GPIO.output(Led_8, GPIO.LOW)

if c==0: GPIO.output(Led_1, GPIO.HIGH)

if c==1: GPIO.output(Led_2, GPIO.HIGH)
if c==2: GPIO.output(Led_3, GPIO.HIGH)
if c==3: GPIO.output(Led_4, GPIO.HIGH)
if c==4: GPIO.output(Led_5, GPIO.HIGH)
if c==5: GPIO.output(Led_6, GPIO.HIGH)
if c==6: GPIO.output(Led_7, GPIO.HIGH)
if c==7: GPIO.output(Led_8, GPIO.HIGH)
time.sleep(0.1)
#----------------------------------
#------------------------------------
print ("PULSADOR PRESIONADO")
break
#--------------------------------------
#----------------------------------------
#--------- SALIENDO LAZO INFINITO ---------
print ("SALIENDO DEL LAZO LOOP")
time.sleep(1)
GPIO.cleanup() #devuelve los pines a su estado inicial

ANEXO2
import Adafruit_DHT

import RPi.GPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

Led_1 = 14

Led_2 = 15

96
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Led_3 = 18

Led_4 = 23

Led_5 = 24

Led_6 = 25

Led_7 = 8

Led_8 = 7

Pulsador = 12

#configuramos el pin GPIO como salida y entrada

GPIO.setup(Led_1, GPIO.OUT)

GPIO.setup(Led_2, GPIO.OUT)

GPIO.setup(Led_3, GPIO.OUT)

GPIO.setup(Led_4, GPIO.OUT)

GPIO.setup(Led_5, GPIO.OUT)

GPIO.setup(Led_6, GPIO.OUT)

GPIO.setup(Led_7, GPIO.OUT)

GPIO.setup(Led_8, GPIO.OUT)

GPIO.setup(Pulsador, GPIO.IN)

def Alarma():

GPIO.output(Led_1, GPIO.HIGH)

GPIO.output(Led_2, GPIO.HIGH)

GPIO.output(Led_3, GPIO.HIGH)

GPIO.output(Led_4, GPIO.HIGH)

GPIO.output(Led_5, GPIO.LOW)

GPIO.output(Led_6, GPIO.LOW)

GPIO.output(Led_7, GPIO.LOW)

GPIO.output(Led_8, GPIO.LOW)

time.sleep(0.1)

97
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

GPIO.output(Led_1, GPIO.LOW)

GPIO.output(Led_2, GPIO.LOW)

GPIO.output(Led_3, GPIO.LOW)

GPIO.output(Led_4, GPIO.LOW)

GPIO.output(Led_5, GPIO.HIGH)

GPIO.output(Led_6, GPIO.HIGH)

GPIO.output(Led_7, GPIO.HIGH)

GPIO.output(Led_8, GPIO.HIGH)

time.sleep(0.1)

while True: #Ingresamos a un lazo infinito

# -------- LAZO INFINITO --------

sensor = Adafruit_DHT.DHT11

pin = 4

humedad, temperatura = Adafruit_DHT.read_retry(sensor, pin)

print ('Humedad: ' , humedad)

print ('Temperatura: ' , temperatura)

if humedad > 50:

Alarma()

i = GPIO.input(Pulsador)

if i==0:

print ("PULSADOR PRESIONADO")

break

#--------- SALIENDO LAZO INFINITO ---------

print ("SALIENDO DEL LAZO LOOP")

time.sleep(1)

98
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

GPIO.cleanup() #devuelve los pines a su estado inicial

ANEXO 3

var https = require('https');

const request = require('request');

var ApiKeyIn = '...................'; // TODO: fill your sensor Api Key In given by https://asksensors.com
var writeInterval = 5000; // TODO: adjust timerInterval (in ms)
// API host name
var host = 'https://api.asksensors.com';

// Function declaration: send data

function send_data(){
var url = host + '/write/';
url+= ApiKeyIn;
url+= '?module1='
url+= 100*Math.random(); // random data in module 1
url+= '&module2='
url+= 100*Math.random(); // random data in module 2
console.log('Data sent to:' + url);
request(url, { json: true }, (err, res, body) => {
if (err) { return console.log(err); }

});
}
send_data();// send first data
// Send data every timerInterval
setInterval(send_data, writeInterval); // setInterval

99
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ANEXO 4
var https = require('https');
var sensorLib = require("node-dht-sensor"); //Librería Sensor
const request = require('request');
var sensorResult = sensorLib.read(11, 4); //Pin sensor

// Configuración de API
var ApiKeyIn = 'd7VSc7Ukq9bxXu0o2lu3JpUsZtOGSblx'; // Clave de mi API
var writeInterval = 5000; // Tiempo de actualización cada 5 segundos
// host name de mi API
var host = 'https://api.asksensors.com';

// Lectura y actualización en vivo cada 2 segundos del sensor en consola

setInterval(function() {
    var readout = sensorLib.read(); //Leo el sensor
 
    console.log('Temperature:', readout.temperature.toFixed(1) + 'C'); //Muestro dato en consola
    console.log('Humidity:   ', readout.humidity.toFixed(1)    + '%');
}, 5000);

// Envío de dato a plataforma configuración

function send_data(){

var readout = sensorLib.read();

var url = host + '/write/';

url+= ApiKeyIn;
url+= '?module1='
url+=  readout.temperature.toFixed(1); // almacena la 1ra variable del sensor en la URL
url+= '&module2='
url+= readout.humidity.toFixed(1); // almacena la 2da variable del sensor en la URL
console.log('Data sent to:' + url);
request(url, { json: true }, (err, res, body) => {
 if (err) { return console.log(err); }

100
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

});
}
send_data();// Envío dato
// Envío dato cada 5 segundo
setInterval(send_data, writeInterval);

ANEXO 5

import RPi.GPIO as GPIO

import serial
import time,sys

SERIAL_PORT = "/dev/ttyS0"
ser=serial.Serial(SERIAL_PORT,baudrate = 115200,timeout=5)

ser.write("AT+CMGF=1\r")
print("Text mode enabled...")
time.sleep(3)
ser.write('AT+CMGS="312234201"\r')
msg="MENSAJE LEONEL...." #aqui editamos el mensaje que queremos enviar
print("sending message....")
time.sleep(3)
ser.write(msg+chr(26))
time.sleep(3)
print("message sent...")

ANEXO 6

#archivo = open("mensajes.log", "r")

#print(archivo.readline()[-1])

#archivo.close()

f=open("mensajes.log","r")

mensaje=f.readlines()[-1]

print(mensaje)

f.close()

101
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ANEXO 7

import RPi.GPIO as GPIO

import serial

import time,sys

SERIAL_PORT = "/dev/ttyS0"

ser=serial.Serial(SERIAL_PORT,baudrate = 115200,timeout=5)

ser.write("AT+CMGF=1\r")

print("Text mode enabled...")

time.sleep(3)

ser.write('AT+CMGS="3502456797"\r')

f=open("mensajes.log","r")

msg=f.readlines()[-1]

print(msg)

f.close()

#msg="MENSAJE LEONEL...."

print("sending message....")

time.sleep(3)

ser.write(msg+chr(26))

time.sleep(3)

print("message sent...")

ANEXO 8
import RPi.GPIO as GPIO

import serial

import time,sys

102
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

SERIAL_PORT = "/dev/ttyS0"

ser=serial.Serial(SERIAL_PORT,baudrate = 115200,timeout=5)

ser.write("ATD3103988056;\r")

print("Dialing....")

#time.sleep(10)

ser.write("ATH\r")

print("Hanging up...")

ANEXO 9
import datetime

def setup():

GPIO.setmode(GPIO.BCM)

GPIO.setwarnings(False)

GPIO.setup(23, GPIO.OUT)

GPIO.setup(24, GPIO.OUT)

GPIO.setup(25, GPIO.OUT)

SERIAL_PORT = "/dev/ttyS0" # Rasp 3 UART Port

ser = serial.Serial(SERIAL_PORT, baudrate = 115200, timeout = 5)

setup()

ser.write("AT+CMGF=1\r") # set to text mode

time.sleep(1)

#ser.write('AT+CMGDA="DEL ALL"\r') # delete all SMS

#time.sleep(1)

reply = ser.read(ser.inWaiting()) # Clean buf

print "Listening for incomming SMS..."

103
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

while True:

reply = ser.read(ser.inWaiting())

if reply != "":

ser.write("AT+CMGR=1\r")

time.sleep(1)

reply = ser.read(ser.inWaiting())

print "SMS received. Content:"

print reply

if "ON" in reply.upper():

if "LED1" in reply.upper():

print "LED 1 ON"

GPIO.output(23,GPIO.HIGH)

if "LED2" in reply.upper():

print "LED 2 ON"

GPIO.output(24,GPIO.HIGH)

if "LED3" in reply.upper():

print "LED 3 ON"

GPIO.output(25,GPIO.HIGH)

if "ALL" in reply.upper():

print ("ALL LED ON")

GPIO.output(23,GPIO.HIGH)

GPIO.output(24,GPIO.HIGH)

GPIO.output(25,GPIO.HIGH)

if "OFF" in reply.upper():

if "LED1" in reply.upper():

print "LED 1 OFF"

GPIO.output(23,GPIO.LOW)

if "LED2" in reply.upper():

print "LED 2 OFF"

GPIO.output(24,GPIO.LOW)

if "LED3" in reply.upper():

print "LED 3 OFF"

104
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

GPIO.output(25,GPIO.LOW)

if "ALL" in reply.upper():

print "ALL LED OFF"

GPIO.output(23,GPIO.LOW)

GPIO.output(24,GPIO.LOW)

GPIO.output(25,GPIO.LOW)

time.sleep(.500)

ser.write('AT+CMGDA="DEL ALL"\r') # delete all

time.sleep(.500)

ser.read(ser.inWaiting()) # Clear buffer

time.sleep(.500)

ANEXOS 10
#include <30f4011.h>

#fuses FRC_PLL16,NOPROTECT,NOWDT,NOPUT

#device adc=10

#use delay(clock=120000000)

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#use RS232(BAUD=115200,BITS=8,PARITY=N,XMIT=PIN_C13,RCV=PIN_C14,STREAM=PC))// UART

#use fast_io(B)

#use fast_io(C)

#use fast_io(D)

#use fast_io(E)

#use fast_io(F)

#define Button PIN_B6

#define LED_Izquierdo PIN_B7

105
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

#define LED_Derecho PIN_B8

#define Cambio_Linea PIN_F5

#define RX PIN_F4

#define Pot sAN4

//Pines Motores OC3 OC4

#define AD pin_E5

#define BD pin_E4

#define AI pin_E2

#define BI pin_E3

/----------- Motores---------/

int16 UL=000; // Velocidad de motor Iquierdo [0 1]

int16 UR=000; // Velocidad de motor Derecho [0 1]

int16 PWM_max=10000; // Máximo valor posible de PWM, depende de configuración PWM

int16 PWM_min=-10000; // Mínimo valor posible de PWM, depende de configuración PWM

/----------------------------/

float Smin=400.0;

float Smax=1023.0;

float SenVal[16];

float sensors_average=0.0;

float sensors_sum=0.0;

int x=0;

int on_line=0;

float line_1=0.0;

float line=0.0;

int8 const N[16][4] ={ {0,0,0,0},

{0,0,0,1},

{0,0,1,0},

{0,0,1,1},

{1,0,0,0},

{1,0,0,1},

106
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

{1,0,1,0},

{1,0,1,1},

{0,1,0,0},

{0,1,0,1},

{0,1,1,0},

{0,1,1,1},

{1,1,0,0},

{1,1,0,1},

{1,1,1,0},

{1,1,1,1}};

/* pines

PIN_RB0 ------ S0

PIN_RB1 ------ S1

PIN_RB2 ------ DP

PIN_RB3 ------ S3

PIN_RB4 ------ S2

*/

float Sensores(int8 Num_Sensor=0)

output_bit(PIN_B3,N[Num_Sensor][0]);

output_bit(PIN_B2,N[Num_Sensor][1]);

output_bit(PIN_B1,N[Num_Sensor][2]);

output_bit(PIN_B0,N[Num_Sensor][3]);

delay_us(100);

int8 ValSensor=0;

set_adc_channel(5); //Establecemos el canal de lectura analogica

float medicion=read_adc (); // Hace conversi?n AD

107
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

//if (medicion>800){

//Valsensor=0;

//}else{

//Valsensor=1;}

//printf (" %f \r ",medicion);

return medicion;

const int Numer_Samples=1; // Muestras por sensor, más muestras para mejor sensado.

const int NumSensors=16; // Numero de sensores

float map(float value, float minSen, float maxSen, float y_min, float y_max)//funcion de normalizacion

float Vcal= (((Value-minSen)*(y_max-y_min))/(maxSen-minSen)) -y_min; // ecuacion de normalizacion

if( Vcal>y_max){Vcal=y_max;}

if( Vcal<y_min){Vcal=y_min;}

return Vcal;

float Minimos,Maximos;

float Max[16] = {0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0};

float Min[16] = {1023.0,1023.0,1023.0,1023.0,1023.0,1023.0,1023.0,1023.0,1023.0,1023.0,

1023.0,1023.0,1023.0,1023.0,1023.0,1023.0};

// Funcion que calibra sensores, encuentra valores maximos y minimos.

void Calibrar_sensores() {

int8 Columna,fila; // Almacenamos en una Matriz la lectura

float SetP=400.0;

float valor=0.0;

float valor2=0.0;

int16 i=0;

108
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

int8 x=0;

int8 y=0;

float vsensor = 0.0;

while(1){

valor=Sensores(0);

valor2=Sensores(15);

if(valor>Setp && valor2>Setp){

for(y=0;y<25;y++){

for(x=0;x<16;x++){

// delay_ms(10);

for(i=0;i<100;i++){

vsensor = Sensores(x);

if(vsensor>Max[x]){

Max[x] = vsensor;

if(vsensor<Min[x] && vsensor!=1023.0){

Min[x] = vsensor;

for(x=0;x<16;x++){

fprintf (PC,"||%f\r",Max[x]);

fprintf (PC,"||%f\r\n",0.0);

for(x=0;x<16;x++){

fprintf (PC,"||%f\r",Min[x]);

109
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

fprintf (PC,"||%f\r\n",0.0);

break;

output_HIGH(Led_Derecho);

output_HIGH(Led_Izquierdo);

delay_ms(100);

output_LOW(Led_Derecho);

output_LOW(Led_Izquierdo);

delay_ms(100);

output_HIGH(Led_Derecho);

output_HIGH(Led_Izquierdo);

float Calcular_Linea() // Funcion que calcula la posicion de la linea

on_line=0;

float Vr=0;

for(x=0;x<16;x++)

SenVal[x]= (Sensores(x)); // lee el pin

/linea negra 1.0 linea blanca 0.0/

Vr=1.0 - map(SenVal[x],Min[x],Max[x],0.0,1.0); // Normaliza el valor leido //Vs,Vm,Vmx,0,1000 []Mx,MIn

//if(x==8){Vr=0.0;}

// printf (" %f \r ",Vr);

//Vr=SenVal[x];

sensors_average+=(Vr * (x)); // Numerador de la ecuacion

110
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

sensors_sum +=Vr; // Denominador de la ecuacion

if (Vr>1){on_line=1;} // Identificador, pero ni idea de xq.

//printf (" %f \r ",sensors_average);

//printf (" %f \r ",sensors_sum);

//printf (" %i \r ",sensors_average);

//printf (" %i \r ",sensors_sum);

if(sensors_average==0 || sensors_sum==0){

sensors_average=1,sensors_sum=1;

//fprintf (PC,"%i\n",Vr);

line=(sensors_average/sensors_sum); // Calculo del valor de linea.

if (sensors_sum>1){

on_line=1;

line_1=line;

}else{

on_line=0;

if (on_line==0){

line = line_1;

sensors_average=0; // Elimina valores

sensors_sum=0;

Vr=0;

return line; // Retorna Calculo de Linea.

111
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

int8 Color_linea=0;

int8 IR=0;

float32 V_pot=0;

int8 pulsador=0;

int8 i=0;

// Accion sobre motores

void Motors(int16 ul,int16 ur)

if (ur>PWM_max){UR=PWM_max;}

if (ul>PWM_max){UL=PWM_max;}

if (ur<PWM_min){UR=PWM_min;}

if (ul<PWM_min){UL=PWM_min;}

if(ur>=0){ //OC4

output_high(AD);

output_low(BD);

set_pwm_duty(4,abs(ur)); // 2ms on status

}else{

output_low(AD);

output_high(BD);

set_pwm_duty(4,abs(ur)); // 2ms on status

if(UL>=0){

output_high(AI);

output_low(BI);

112
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

set_pwm_duty(3,abs(ul)); // 2ms on status

}else{

output_low(AI);

output_high(BI);

set_pwm_duty(3,abs(ul)); // 2ms on status

void init_Motors(){

setup_timer3(TMR_INTERNAL | TMR_DIV_BY_8, 65500);

setup_compare(1,COMPARE_PWM | COMPARE_TIMER3 );

set_pwm_duty(1,4000); //Minimo 40000 para encender

delay_ms(1500);

setup_timer2(TMR_INTERNAL | TMR_DIV_BY_1, PWM_max );

setup_compare(3,COMPARE_PWM | COMPARE_TIMER2 );

setup_compare(4,COMPARE_PWM | COMPARE_TIMER2 );

set_pwm_duty(3,0000);

set_pwm_duty(4,0000);

//ENABLE_INTERRUPTS(INTR_GLOBAL);

int16 V_Max=0, U_Max, U_Min;

float U,Up,Ud,Ud_1,error,error_1,linea;

int16 Kp,Kd;

int16 U_Base; // Se define en función: Tunning

int16 Tur;

void Tunning(){

Tur=5000;

Kp=3.5*1000.0;

float Td=4.6;

113
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

Kd=Kp*Td;

V_Max=4000;//0.25 // Determina la velocidad del Robot

U_Max=PWM_max;

U_Min=PWM_min;

void OptimalSpeed(){

// Sección Guarant Control del Paper

int16 delta;

if(UR>U_MAX){

delta = U_MAX - UR;

U_Base = U_Base + delta;

UL=U_Base - 0.5*U; // Accion sobre motor Izquierdo

UR=U_Base + 0.5*U; // Accion sobre motor Derecho

if(UL>U_MAX){

delta = U_MAX - UL;

U_Base = U_Base + delta;

UL=U_Base - 0.5*U; // Accion sobre motor Izquierdo

UR=U_Base + 0.5*U; // Accion sobre motor Derecho

void PID(){

// Accion proporcional

Up= Kp*error;

// Accion Derivativa

Ud = Kd*(error-error_1);

// Accion de Control

U=Up+Ud;

114
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

// fprintf (PC,"||%f\r\n",U);

error_1 = error;

Ud_1=Ud;

void main()

set_tris_B(0b000100000);

set_tris_F(0xFF);

set_tris_E(0x00);

set_tris_D(0x00);

fprintf (PC,"Hello World, My Name is Mustang!!!!! %i\r\n",1);

setup_adc(ADC_CLOCK_INTERNAL); // Configura el conversor

setup_adc_ports( sAN5 ); // Configura el conversor

init_Motors();

Tunning();

output_HIGH(Led_Derecho);

output_HIGH(Led_Izquierdo);

// Boton o Rx de arranque

while(1){

if (input(RX)==0 || input(Button)==1)

output_LOW(Led_Derecho);

output_LOW(Led_Izquierdo);

Calibrar_sensores();

break;

115
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

while(1)

linea=Calcular_Linea();

printf (" %f\r\n",linea);

error=8.0 - linea;

if (error>0){

output_HIGH(LED_Izquierdo);

output_LOW(LED_Derecho);

}else{

output_LOW(LED_Izquierdo);

output_HIGH(LED_Derecho);}

PID(); // Determina accion de control U

U_Base =3000; // Valor asignado en la funcion: Tunning

UL=U_Base - 0.5*U; // Accion sobre motor Izquierdo

UR=U_Base + 0.5*U; // Accion sobre motor Derecho

OptimalSpeed();

//UR=UL=00;

Motors(UL,UR);

// printf (" %f %f %f \r\n",linea,Up,Ud);

// printf (" %f\r\n",linea);

/*if (input(RX)==0)

output_LOW(Led_Derecho);

output_LOW(Led_Izquierdo);

Motors(0000,0000);

delay_ms(2000);

break;

116
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

117
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ANEXO 11

118
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

FIRMA ESTUDIANTES

FIRMA ASESOR

FECHA ENTREGA: _____________

FIRMA COMITÉ TRABAJO DE GRADO DE LA FACULTAD

RECHAZADO ACEPTADO____ ACEPTADO CON

MODIFICACIONES_______

ACTA NO._____________

FECHA ENTREGA: _____________

FIRMA CONSEJO DE FACULTAD_____________________________________

119
 Código FDE 089
INFORME FINAL DE
Versión 03
TRABAJO DE GRADO
Fecha 2015-01-22

ACTA NO._____________

FECHA ENTREGA: _____________

120