DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE ...

DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE INSTRUCCIONES SOBRE EL MÓDULO DE COMUNICACIONES SIM5320A

JOHAN ANDREY BARÓN ALFARO

UNIVERSIDAD PILOTO DE COLOMBIA FACULTAD DE INGENIERÍA

PROGRAMA DE INGENIERÍA DE SISTEMAS BOGOTÁ

2018

DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE INSTRUCCIONES SOBRE EL MÓDULO DE COMUNICACIONES SIM5320A

TRABAJO DE GRADO PARA OPTAR POR EL TÍTULO DE INGENIERO DE SISTEMAS

JOHAN ANDREY BARÓN ALFARO

ASESOR: DIEGO BERMÚDEZ COASESOR: JHON VILLARREAL

UNIVERSIDAD PILOTO DE COLOMBIA FACULTAD DE INGENIERÍA

PROGRAMA DE INGENIERÍA DE SISTEMAS BOGOTÁ

2018

4

TESIS DE GRADO: DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE INSTRUCCIONES SOBRE EL MÓDULO DE COMUNICACIONES SIM5320A

AUTOR: JOHAN ANDREY BARÓN ALFARO ASESOR: DIEGO BERMÚDEZ

NOTA DE ACEPTACIÓN _____________________________ _____________________________ _____________________________ _____________________________ _____________________________

_____________________________ Presidente del Jurado

_____________________________ Jurado

_____________________________ Jurado

5

AGRADECIMIENTOS

En primer lugar, agradezco a los asesores de este trabajo de grado, Dr. Diego Bermúdez y Mgtr. Jhon Villareal por su valiosa dirección y apoyo para desarrollar este proyecto y llegar a la conclusión del mismo.

Agradezco también al ingeniero Fabían Gaitán, quien me permitió hacer parte de uno de los proyectos de la universidad y así poder terminar mi ciclo profesional universitario.

A mi esposa Diana Marcela, por su apoyo, por exigirme cuando debía y acompañarme en las trasnochadas.

Y finalmente, a mis hijos y mis padres que, a través de ese amor de familia, se convirtieron en otra excusa más para graduarme y cerrar este ciclo de mi vida.

6

CONTENIDO

ÍNDICE DE FIGURAS ....................................................................................................... 8

ÍNDICE DE TABLAS ......................................................................................................... 9

ÍNDICE DE ANEXOS ...................................................................................................... 10

GLOSARIO ..................................................................................................................... 11

RESUMEN ....................................................................................................................... 12

ABSTRACT ..................................................................................................................... 13

INTRODUCCIÓN ............................................................................................................. 14

1. PROBLEMA ............................................................................................................ 15

2. JUSTIFICACIÓN ..................................................................................................... 16

3. ALCANCE ............................................................................................................... 17

4. OBJETIVOS ............................................................................................................ 18

4.1 OBJETIVO GENERAL .......................................................................................... 18 4.2 OBJETIVOS ESPECÍFICOS ................................................................................ 18

5. MARCO TEÓRICO .................................................................................................. 19

5.1 ESTADO DEL ARTE ............................................................................................ 19 5.2 MARCO CONCEPTUAL ....................................................................................... 20 5.3 MARCO REFERENCIAL ...................................................................................... 22

5.3.1 Adafruit FONA 3G. ....................................................................................... 22 5.3.2 Conjunto de comandos AT ........................................................................... 23 5.3.3 AT+NETOPEN ............................................................................................. 24 5.3.4 AT+CGDCONT.. ........................................................................................... 25 5.3.5 AT+CSOCKSETPN. ..................................................................................... 26 5.3.6 AT+CHTTPSSTART ..................................................................................... 27 5.3.7 AT+CHTTPSSTOP ....................................................................................... 27 5.3.8 AT+CHTTPSOPSE ...................................................................................... 28 5.3.9 AT+CHTTPSSEND ...................................................................................... 29 5.3.10 AT+CHTTPSRECV ................................................................................... 30 5.3.11 AT+CHTTPSCLSE ................................................................................... 31

6. METODOLOGÍA ...................................................................................................... 32

7. DESARROLLO DEL PROYECTO ........................................................................... 33

7.1 CONFIGURACIÓN E INSTALACIÓN DEL LABORATORIO ................................. 33 7.1.1 Conexión ...................................................................................................... 36 7.1.2 Prueba de conexión. ..................................................................................... 37

7.2 DESARROLLO DE SOFTWARE .......................................................................... 38 7.2.1 Historias de usuario ...................................................................................... 38 7.2.2 Diagrama de clases ...................................................................................... 40 7.2.3 Flujo de Comandos para una petición HTTP. ............................................... 43

7

7.3 PRUEBAS ............................................................................................................ 45 7.3.1 Enviar petición HTTP .................................................................................... 45 7.3.2 Obtener la lista de mensajes de texto ........................................................... 46 7.3.3 Ejecutar mensaje en Python ......................................................................... 47 7.3.4 Ejecutar mensaje en FONA .......................................................................... 47 7.3.5 Enviar mensaje de texto ............................................................................... 47 7.3.6 Leer mensaje de texto .................................................................................. 48 7.3.7 Obtener el estado de la batería .................................................................... 49 7.3.8 Obtener el IMEI del módulo FONA ............................................................... 49

8. CONCLUSIONES .................................................................................................... 50

9. TRABAJO FUTURO ................................................................................................ 51

BIBLIOGRAFÍA ............................................................................................................... 52

LISTA DE REFERENCIAS .............................................................................................. 53

8

ÍNDICE DE FIGURAS

Figura 1: Módulo Adafruit FONA 3G ................................................................................ 34

Figura 2: Batería de Ion litio - 3.7 v 1200 mAh ................................................................. 34

Figura 3: Antena tipo sticker ............................................................................................ 35

Figura 4: Cable USB a TTL Serial .................................................................................... 35

Figura 5: Raspberry Pi 3 modelo B .................................................................................. 36

Figura 6: Conexión Adafruit FONA 3G ............................................................................. 37

Figura 7: Diagrama de clases .......................................................................................... 41

Figura 8: Diagrama de Flujo de componentes ................................................................. 44

Figura 9: Recepción del sms ........................................................................................... 48

9

ÍNDICE DE TABLAS

Tabla 1: Proyecto Adafruit Fona en Github ...................................................................... 19

Tabla 2: Proyecto TinyGSM ............................................................................................. 20

Tabla 3: Ejemplo REST ................................................................................................... 22

Tabla 4: Sintaxis de comandos AT .................................................................................. 23

Tabla 5: Sintaxis de comando NETOPEN ........................................................................ 24

Tabla 6: Valores definidos para NETOPEN ..................................................................... 24

Tabla 7: Sintaxis de comando CGDCONT ....................................................................... 25

Tabla 8: Valores definidos para CGDCONT ..................................................................... 25

Tabla 9: Sintaxis de comando CSOCKSETPN ................................................................ 26

Tabla 10: Valores definidos para CSOCKSETPN ............................................................ 27

Tabla 11: Sintaxis de comando CHTTPSSTART ............................................................. 27

Tabla 12: Sintaxis de comando CHTTPSSTOP ............................................................... 28

Tabla 13: Sintaxis de comando CHTTPSOPSE ............................................................... 28

Tabla 14: Valores definidos para CHTTPSOPSE............................................................. 28

Tabla 15: Sintaxis de comando CHTTPSSEND ............................................................... 29

Tabla 16: Valores definidos para CHTTPSSEND............................................................. 29

Tabla 17: Sintaxis de comando CHTTPSRECV ............................................................... 30

Tabla 18: Valores definidos para CHTTPSRECV............................................................. 30

Tabla 19: Sintaxis de comando CHTTPSCLSE ............................................................... 31

Tabla 20: Elementos del laboratorio................................................................................. 33

Tabla 21: Historias de usuario ......................................................................................... 39

Tabla 22: Estructura del arreglo del mensaje ................................................................... 47

10

ÍNDICE DE ANEXOS

ANEXO A. adafruit-fona-3g-cellular-gps-breakout.pdf

ANEXO B. SIMCOM_SIM5320_ATC_EN_V2.02.pdf

ANEXO C. Manual de Usuario Pyfona.pdf

11

GLOSARIO

Esta es una recopilación de definiciones y términos utilizados en el proyecto, se incluyen los más importantes, poco conocidos, de difícil interpretación o que no sean comúnmente utilizados en el contexto:

Contexto PDP: Especifica el acceso a una red externa de intercambio de paquetes. Los datos asociados con el contexto PDP contienen la información tales como el tipo de red de intercambio de paquetes, la dirección IP, la referencia GGSN y los QoS solicitados. GGSN (Gateway GPRS Support Node): Es la puerta de enlace o punto central de conexión de una red celular. Esta puede ser una red como internet o una red corporativa. GSM: Sistema global para comunicaciones móviles. MT: Terminación móvil. PDP (Packet Data Protocol): Es un protocolo de transferencia de paquetes utilizado en redes inalámbricas GPRS / HSDPA. Cuando los datos tienen que transmitirse, se dividen en estructuras de datos similares a las anteriores a la transmisión, llamadas paquetes, que se vuelven a ensamblar una vez que llegan a su destino. Un paquete también se denomina datagrama, segmento, bloque, celda o marco, según el protocolo utilizado para la transmisión de datos. Los sistemas GPRS son compatibles con los protocolos de capa de red X.25 y IP. Por lo tanto, las direcciones PDP pueden ser X.25, IP o ambas. SCREEN: Es una herramienta de Unix cuyo cometido no es otro que crear terminales virtuales. Esto le permite conectarse a un puerto serial, por ejemplo.

UML (Unified Modeling Language): Es un lenguaje gráfico para visualizar, especificar, construir y documentar un sistema. UML ofrece un estándar para describir un "plano" del sistema (modelo), incluyendo aspectos conceptuales tales como procesos, funciones del sistema, y aspectos concretos como expresiones de lenguajes de programación, esquemas de bases de datos y compuestos reciclados.

12

RESUMEN En el proyecto DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE INSTRUCCIONES SOBRE EL MÓDULO DE COMUNICACIONES SIM5320A se implementa una solución de software frente a la no existencia actual de una librería en Python para la gestión del módulo mencionado. Actualmente en carreras como Ingeniería de Telecomunicaciones, los estudiantes utilizan estos módulos de telefonía y comunicaciones para realizar aplicaciones y extensiones de sus estudios y similares; como tal, dentro de este proceso deben aprender a utilizar los protocolos y comandos de gestión de dichos dispositivos. Al ser comandos repetitivos y que deben ser ingresados en forma serial, esto convierte la gestión del módulo en algo tedioso y poco útil en proyectos cuyo alcance están por encima de esta capa (recolección e información en campo, envío de información por internet, etc.). Como solución, en este proyecto se hace una investigación sobre los proyectos de código abierto existentes que podrían aplicar como alternativa para la solución requerida, con su consecuente análisis. Luego se sugiere y justifica el por qué realizar una solución escogiendo Python como lenguaje de programación y se definen las funcionalidades a ser desarrolladas. En una siguiente etapa y utilizando la metodología de investigación aplicada, se diseña la arquitectura de la aplicación, ambiente de conexión y configuración (hardware) y desarrollo (software) junto con su respectivo ciclo de pruebas. Resultado del trabajo realizado, se obtiene un producto de software con las funcionalidades trazadas en los objetivos, su correspondiente manual de usuario y se plantean las posibles aplicaciones futuras a utilizar.

13

ABSTRACT In this project PYTHON LIBRARY DEVELOPMENT FOR CONTROL OF INSTRUCTIONS ON THE SIM5320A COMMUNICATIONS MODULE, a software solution is implemented facing the present non-existence of a Python library for the management of the aforementioned module. Currently in careers as Telecommunications Engineering, students use these telephony and communications modules to create applications, developing laboratories or similars; as such, within this process they must learn to use the protocols and management commands of these devices. Being repetitive commands that must be entered serially, this makes the management of the module somewhat tedious and not very useful in projects whose scope is above this layer (gathering information on field, sending information through the Internet, etc.). As a solution, in this project is made an investigation on the existing open source projects that could be applied as an alternative for the required solution, with its consequent analysis. Then it is suggested and justified why Python is chosen as the programming language to implement the solution, and in turn, the functionalities to be developed are defined. In a next stage and using applied research methodology, the architecture of the application, connection and configuration environment (hardware) and development (software) is designed along with its respective test cycle. As a result of the executed project, the solution has the features outlined as objective, its corresponding user manual and the possible future applications to be used.

14

INTRODUCCIÓN El presente documento es la sustentación del trabajo de grado que lleva por nombre DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE INSTRUCCIONES SOBRE EL MÓDULO DE COMUNICACIONES SIM5320A. Este va dirigido a estudiantes, investigadores y profesionales que buscan una solución de software que facilite la utilización de las características de software y hardware del módulo de telefonía Adafruit Fona 3G. Dentro de un contexto mayor del presente proyecto, se encuentra enmarcada una política nacional que busca la creación de ciudades y espacios inteligentes [1], la cual es adoptada por el grupo de investigación InnovaTIC de la universidad Piloto de Colombia a través del proyecto: “Guía de articulación, planeación y despliegue para el desarrollo de escenarios de prestación de servicios locales y nacional para la creación ciudades inteligentes que derivan a territorios inteligentes en Colombia aprendiendo de las experiencias de sistemas inteligentes de Transporte”. Mediante esta, se pretende contribuir en la definición de un marco de trabajo que brinde a cualquier ente gubernamental una visión clara y concisa para que sea utilizada a nivel nacional y permita el correcto desarrollo y despliegue de este tipo de proyectos. En el detalle técnico de este proyecto se plantea la utilización de dispositivos movibles que, por su adaptabilidad y portabilidad, son claves para contribuir en el problema planteado ya que permitirían recoger, procesar y enviar información de forma remota y autónoma haciendo uso sensores, redes de comunicaciones celular, etc.. Consecuentemente en este documento y mediante la metodología de investigación aplicada, se presenta el diseño, desarrollo y pruebas realizadas utilizando como hardware un Raspberry Pi 3, su conexión, instalación y configuración hacia el módulo Adafruit Fona 3G y su correspondiente ciclo de pruebas y conclusiones.

15

1. PROBLEMA

Hoy en día la sociedad está evolucionando hacia lo que conocemos como SMART Cities. Uno de los propósitos de esta evolución es poder monitorizar y recolectar información de todas las variables que sean útiles para la comunidad, como por ejemplo variables del ambiente, estado del tráfico, situaciones de emergencia, entre otras. Sin importar cuál sea la variable del entorno bajo análisis, ésta debe ser transmitida desde un sensor, ubicado en el campo de acción, a un servidor de almacenamiento y/o procesamiento el cual, normalmente, se encuentra en la nube. Hoy en día existen diversos dispositivos, tales como el FONA 3G, que permiten enviar información a un servidor remoto utilizando la red de telefonía GPRS/3G. Sin embargo, la configuración y uso de estos elementos no suele ser una tarea fácil. Algunos lenguajes de programación de alto nivel, como Python, ofrecen la posibilidad de interactuar con estos módulos de transmisión de forma clara y sencilla. No obstante, no existe una librería en este lenguaje de programación que permita hacer uso de las capacidades de estos dispositivos de telefonía. Teniendo en cuenta su importancia como componente técnico en el desarrollo de objetivos en proyectos de mayor alcance, se nos presenta el siguiente interrogante ¿Es posible crear una librería en Python que me permita hacer uso de las capacidades de estos módulos de transmisión, para poder reducir el trabajo en proyectos de SMART cities?

16

2. JUSTIFICACIÓN Dentro del contexto nacional colombiano, desde el año 2013, el ministerio de las TIC estableció una política nacional de ciudades y territorios inteligentes [2] donde se plantea lo siguiente “se evidencia que las Tecnologías de la Información y las Comunicaciones contribuyen de forma sustancial a la conformación de ciudades inteligentes”. Por ende, la base del logro de esta iniciativa nacional es la necesidad de involucrar los elementos en software, hardware y saber, como partícipes en este objetivo global. En este mismo camino y yéndonos a un detalle más reducido, son las áreas de Telecomunicaciones y Sistemas las que deben responder a este tipo de necesidad. Es por eso que, en este proyecto, se escoge un elemento de hardware que perfectamente puede ser partícipe de una solución de cobertura local (ciudad o municipio) que, junto con el software adecuado, representa un primer elemento de recolección de información autónomo. Para nuestro caso, el módulo de comunicaciones SIM5320a de SIMCom (chip principal del Adafruit FONA 3G) permite mediante una interfaz tipo serial, utilizar el conjunto de comandos Hayes [3] o comandos AT para realizar una serie de funciones específicas. A pesar de que este conjunto de instrucciones interpretado no es extenso, es poco útil o extenso para cualquier estudiante o profesional, que desea hacer un uso extensivo de este módulo, tener que aprender o ejecutar estos comandos de forma manual. Por lo tanto la intención de este proyecto de grado es crear un conjunto de clases a manera de librería en Python que sea fácilmente portable, fácil de leer, que simplifique y permita la utilización de esta serie de instrucciones AT para el módulo FONA. Con la librería desarrollada, se busca generar un impacto en todo tipo de proyectos de ingeniería que deseen utilizar dispositivos portátiles, autónomos, de recolección de datos y similares (tipo Arduino) que busquen o tengan como funcionalidad el envío de información de forma autónoma, óptima y remota.

17

3. ALCANCE Desarrollar un producto de software programado en Python 2.7 que permita abstraer, simplificar, e implementar varias de las funcionalidades principales del módulo Adafruit FONA 3G.

18

4. OBJETIVOS

4.1 OBJETIVO GENERAL

Desarrollar una librería que permita la comunicación y manipulación del módulo de telefonía Adafruit FONA 3G para facilitar su utilización y extensión en usabilidad, utilizando la metodología de investigación aplicada.

4.2 OBJETIVOS ESPECÍFICOS

El módulo Adafruit FONA 3G cuenta con la mayoría de características de telecomunicaciones que suelte tener también un teléfono celular, por lo tanto las funcionalidades escogidas para ser abstraídas e implementadas en este proyecto son:

Consumir servicios JSON-RESTFul soportando los métodos HTTP GET, POST, PUT y DELETE abriendo una conexión GPRS a partir de datos de configuración de un APN. El resultado de la petición, debe ser devuelto a su invocador.

Retornar el listado de mensajes de texto disponibles en la línea celular.

Permitir la ejecución de código Python a partir de un identificador de mensaje de texto.

Permitir la ejecución de código AT sobre el módulo Adafruit Fona 3G a partir de un identificador de mensaje de texto.

Obtener el porcentaje de nivel de carga de la batería del módulo de telefonía.

Enviar mensajes de texto.

Obtener el IMEI del equipo.

19

5. MARCO TEÓRICO

5.1 ESTADO DEL ARTE

En el momento de realizar este trabajo de grado, se buscaron proyectos de código abierto que cumplieran las necesidades planteadas en el problema de este documento. El resultado de la investigación arrojó que solamente dos proyectos cumplen con características que se acercan a la solución. La primera por parte del fabricante del dispositivo de telefonía y una segunda, cuya información se describe más adelante.

Como primera alternativa de solución, Adafruit, tiene un proyecto en la plataforma de código Github [4] para la manipulación de algunos módulos de telefonía. En la Tabla 1 se detallan las características del proyecto en mención.

Tabla 1: Proyecto Adafruit Fona en Github

URL https://github.com/adafruit/Adafruit_FONA/

Lenguaje de Programación

C++

Dispositivos compatibles

Adafruit FONA - Mini Cellular GSM Breakout uFL Version Adafruit FONA - Mini Cellular GSM Breakout - SMA Version - v1 Adafruit FONA 800 Shield - Voice/Data Cellular GSM for Arduino Adafruit FONA 808 - Mini Cellular GSM + GPS Breakout

Funcionalidades

Funciones de reloj Estado de batería y voltaje Radio FM Desbloqueo de SIM GPRS GPS TCP HTTP (funciones de bajo y alto nivel)

Fuente: Propia

A pesar que dentro del código existen funcionalidades implementadas para el Adafruit Fona 3G [5], todas las funciones e instrucciones están enfocadas en el chip SIM800H, lo que lo convierte en poco compatible con el módulo de este proyecto (SIM5320A). Adicionalmente, el proyecto en Github construído en C++

20

requiere de un desarrollador conocedor del lenguaje y por lo tanto, su extensión no satisfaría la necesidad original de ser algo fácil de utilizar como interfaz hacia el módulo de telefonía.

Como segunda alternativa de solución, se encontró una librería para Arduino que se llama TinyGSM [6] cuyas características se muestran en la Tabla 2.

Tabla 2: Proyecto TinyGSM

URL https://github.com/vshymanskyy/TinyGSM

Lenguaje de Programación

C++

Dispositivos compatibles

SIM8xx

Funcionalidades Ver información en la referencia [6]

Fuente: Propia

A pesar de que el proyecto cuenta con un conjunto de funcionalidades bastante completo, carece de compatibilidad con el chip SIM5320A, Al igual que el proyecto presentado en la Tabla 1.

Como se ha podido observar existen muy pocas alternativas, con funcionalidades muy limitadas que no cubren las necesidades para el caso concreto del presente proyecto.

5.2 MARCO CONCEPTUAL

En este capítulo se describen los conceptos generales a partir de los cuales se sustenta el trabajo realizado durante este proyecto. Teniendo en cuenta que el módulo Adafruit FONA 3G cuenta en su núcleo con el chip SIM5320, es muy importante entender los protocolos de comunicación y también, los conjuntos de instrucciones que soporta es módulo de telefonía. Adicionalmente las funcionalidades a implementar planteados en los objetivos específicos, también incluyen una terminología sobre protocolos y especificaciones que corren sobre la capa HTTP, estos son explicados a continuación:

21

CONJUNTO DE COMANDOS HAYES: Es un lenguaje desarrollado por la compañía Hayes Communications que prácticamente se convirtió en estándar abierto de comandos para configurar y parametrizar módems. Los caracteres «AT», que preceden a todos los comandos, significan «Atención», e hicieron que se conociera también a este conjunto de comandos como comandos AT. Un aparato que implemente el conjunto de comandos Hayes se considera compatible Hayes. Parte del conjunto de comandos Hayes fue incluido por la ITU-T en el protocolo V.25ter, actual V.250. La adopción de este estándar hizo el desarrollo de controladores específicos para distintos módems superfluo.

GPRS: El servicio general de paquetes vía radio, en inglés: General Packet Radio Service (GPRS), fue creado en la década de los 80 Una conexión GPRS está establecida por la referencia a su nombre de punto de acceso (APN). Con GPRS se pueden utilizar servicios como Wireless Application Protocol (WAP), servicio de mensajes cortos (SMS), Multimedia Messaging System (MMS), Internet y para los servicios de comunicación, como el correo electrónico y la World Wide Web (WWW). Para fijar una conexión de GPRS para un módem inalámbrico, un usuario debe especificar un APN, opcionalmente un nombre y contraseña de usuario, y muy raramente una dirección IP, todo proporcionado por el operador de red.

JSON: Acrónimo de JavaScript Object Notation, es un formato de texto ligero para el intercambio de datos. JSON es un subconjunto de la notación literal de objetos de JavaScript aunque hoy, debido a su amplia adopción como alternativa a XML, se considera un formato de lenguaje independiente.

REST: La transferencia de estado representacional (en inglés representational state transfer) o REST es un estilo de arquitectura software para sistemas hipermedia distribuidos como la World Wide Web. El término se originó en el año 2000, en una tesis doctoral sobre la web escrita por Roy Fielding, uno de los principales autores de la especificación del protocolo HTTP y ha pasado a ser ampliamente utilizado por la comunidad de desarrollo. De acuerdo a la arquitectura REST, las cosas deben hacerse de una manera simple cuando se exponen servicios por HTTP, como se muestra en la Tabla 3:

https://www.wikiwand.com/es/JavaScript

https://www.wikiwand.com/es/XML

https://www.wikiwand.com/es/Idioma_ingl%C3%A9s

https://www.wikiwand.com/es/Hipermedia

https://www.wikiwand.com/es/World_Wide_Web

https://www.wikiwand.com/es/2000

https://www.wikiwand.com/es/Roy_Fielding

https://www.wikiwand.com/es/HTTP

22

Tabla 3: Ejemplo REST

Método Path Acción

GET /usuarios Obtener todos los usuarios

GET /usuarios/id Obtiene el usuario con identificador igual a id

POST /usuarios Crea un usuario nuevo

PUT /usuarios/ Actualiza el usuario con el identificador enviado desde la aplicación

DELETE /usuarios/id Elimina el usuario con el identificador igual a id

Fuente: Propia

CIUDAD INTELIGENTE: Es una ciudad caracterizada por adelantar actividades de conocimiento intensivo, cooperar para apropiar conocimiento, tener una infraestructura tecnológica desarrollada y alta capacidad de innovar y resolver problemas [7].

5.3 MARCO REFERENCIAL El componente principal utilizado en este proyecto de grado, es el módulo de telefonía ADAFRUIT FONA 3G. Por lo tanto en este punto se revisará el detalle técnico del dispositivo y el conjunto de órdenes utilizadas dentro de su protocolo de manejo.

5.3.1 Adafruit FONA 3G. El FONA 3G es un módulo hecho por Adafruit Industries que viene incluido con el chip SIM5320 de SIMCom. Como su nombre lo indica, soporta redes 3G, GSM, geolocalización GPS. Adicionalmente este dispositivo permite hacer uso mensajes de texto, mensajes de voz y rastreo de ubicación. Las medidas de este módulo son: 4,5 por 4 centímetros. En el núcleo se encuentra el módulo celular GSM SIM5320 con GPS integrado y la siguiente es la lista de características técnicas:

Quad-band 850MHz GSM, 900MHz EGSM, 1800MHz DCS, 1900MHz PCs.

Versión Americana dual-band UMTS/HSDPA 850/1900MHz WCDMA + HSDPA.

Versión Europea dual-band UMTS/HSDPA 900/2100MHz WCDMA + HSDPA.

23

GPS integrado (Qualcomm PM8015 GPS) que puede ser controlado y manejado sobre el mismo puerto serial.

Realizar y recibir llamadas de voz utilizando audífonos o un speaker externo de 8Ω con micrófono electrónico.

Enviar y recibir mensajes SMS.

Enviar y recibir GPRS data (TCP/IP, HTTP, etc.).

La interfaz de comando AT puede ser utilizada a velocidades 300, 600, 1200, 4800, 9600, 19200, 39400, 57600, 115200, 230K, 461K, 961K, 3.2M, 3.7M y 4.0Mbps.

5.3.2 Conjunto de comandos AT. El módulo de telefonía cuenta con una interfaz de comunicación serial para su manipulación. A través de este puerto y la conexión adecuada, es posible utilizar un conjunto de comandos AT definidos en el manual de usuario. Debido a la gran cantidad de comandos, solamente se referencian los comandos utilizados durante el proyecto y su respectivo uso.

El comando básico permitido sobre este tipo de dispositivos es AT, el cual fue abreviado de la palabra en inglés ATention (atención en inglés). Los demás comandos siguen la sintaxis que se explica en la Tabla 4.

Tabla 4: Sintaxis de comandos AT

Comando de prueba

AT+<COMANDO>=? Prueba la existencia del comando; ofrece algo de información sobre los subparámetros del comando

Comando de lectura

AT+<COMANDO>? Verifica los valores actuales de los subparámetros

Comando de escritura

AT+<COMANDO>=<...> Asigna los valores de subparámetros definidas por el usuario

Comandos de ejecución

AT+<COMANDO> Leer subparámetros no variables determinados por el proceso interno.

Fuente: Propia

24

5.3.3 AT+NETOPEN. A través de este comando se abre la conexión de red para el posterior envío de mensajes HTTP. En la Tabla 5 se especifica la sintaxis de este comando.

Tabla 5: Sintaxis de comando NETOPEN

Comando de lectura Respuestas

AT+NETOPEN? +NETOPEN:<net_state>,<mode> OK

ERROR

+CME ERROR: <err>

Comando de ejecución Respuestas

AT+ NETOPEN OK +NETOPEN: <err>

+NETOPEN: <err> OK

+NETOPEN: <err> ERROR

ERROR

Fuente: Propia

En la Tabla 6 se especifica el conjunto de valores que pueden tomar las respuestas de los comandos NETOPEN definidos en la Tabla 5.

Tabla 6: Valores definidos para NETOPEN

<net_state>

A parámetro numérico que indica el estado del contexto de activación PDP: 0 - red cerrada (desactivada) 1 - red abierta (activada)

<mode>

Un parámetro numérico que establece el modo de utilización del módulo. En el presente, soporta 3 modos, tales como single-client, tcp-server y multi-client. Si <mode> es 1, entonces <sock_type> y <port> son ignorados. 0 - single-client o tcp-server, este es solo utilizado para ser compatible con un set de comandos TCP viejos 1 - multi-client

<err>

El resultado de la operación, 0 es éxito. Cualquier otro valor es un fallo

Fuente: Propia

25

5.3.4 AT+CGDCONT. Este comando especifica los valores de los parámetros del contexto socket PDP para un contexto de PDP identificado por el parámetro <cid>. El número de contextos PDP que pueden estar en un estado definido al mismo tiempo está dado por el rango retornado por el comando de prueba. En la Tabla 7 se especifica la sintaxis de este comando.

Tabla 7: Sintaxis de comando CGDCONT

Comando de prueba Respuestas

AT+CGDCONT=? +CGDCONT: (rango de <cid> soportados), <PDP_TYPE>,,, (lista de <d_comp> soportados), (lista de <h_comp> soportados) OK

ERROR


AT+ CGDCONT? +CGDCONT: [<cid>, <PDP_type>, <APN>, <PDP_addr>, <d_comp>, <h_comp>[<CR><LF> +CGDCONT: <cid>, <PDP_type>,<APN>, <PDP_addr>, <d_comp>, <h_comp>[...]]] OK

ERROR

Comando de escritura Respuestas

AT+ CGDCONT= <cid> [,<PGP_type>[, <APN>[, <PDP_addr>[, <d_comp>[,<h_comp> ]]]]]

OK

ERROR


AT+ CGDCONT OK

ERROR

Fuente: Propia

En la Tabla 8 se especifica el conjunto de valores que pueden tomar las respuestas de los comandos CGDCONT definidos en la Tabla 7.

Tabla 8: Valores definidos para CGDCONT

<cid>

(Identificador del contexto PDP) Es un parámetro numérico el cual especifica una definición de contexto en particular. El rango de valores permitidos es devuelto con el comando de prueba. 1 ... 16

26

<PDP_type>

(Packet Data Protocol type) Es una cadena de texto la cual especifica el tipo de protocolo de datos en modo paquete. IP - Protocolo de internet PPP - Protocolo punto a punto IPV6 - Protocolo de internet versión 6

<APN>

(Access Point Name) Es un parámetro en forma de cadena de texto que representa el nombre lógico que es utilizado para seleccionar el GGSN o la red del protocolo de datos en modo paquete.

<PDP_addr>

Una cadena de texto que identifica el MT en el espacio de la dirección aplicable al PDP. El comando de lectura seguirá retornando una cadena vacía incluso si una dirección ha sido asignada durante el procedimiento de inicio del PDP

<d_comp>

Parámetro numérico que controla la comprensión de datos del PDP 0 - off (el valor por defecto es omitido) 1 - on 2 - V.42.bis

<h_comp>

Parámetro numérico que controla la comprensión de datos de la cabecera del PDP 0 - off (el valor por defecto es omitido) 1 - on 2 - RFC1144 3 - RFC2507 4 - RFC3095

Fuente: Propia

5.3.5 AT+CSOCKSETPN. Este comando activa el número de perfil de contexto del PDP. Cuando activamos el PDP al utilizar el comando AT+NETOPEN, necesitamos utilizar el número de perfil por defecto, y el contexto de este perfil es configurado por el comando AT+CKSOCKCONT. En la Tabla 9 se especifica la sintaxis de este comando. Tabla 9: Sintaxis de comando CSOCKSETPN


AT+CSOCKSETPN=? +CSOCKSETPN: (lista de los perfiles soportados <profile_number>) OK

ERROR

27


AT+ CSOCKSETPN? +CSOCKSETPN: <profile_number> OK

ERROR


AT+ CSOCKSETPN= <profile_number>

OK

ERROR


AT+ CSOCKSETPN OK

ERROR

Fuente: Propia

En la Tabla 10 se especifica el conjunto de valores que pueden tomar las respuestas de los comandos CSOCKSETPN definidos en la Tabla 9.

Tabla 10: Valores definidos para CSOCKSETPN

<profile_number>

Parámetro numérico que identifica el número de perfil por defecto. El rango de valores permitidos está entre 1 y 16 1 ... 16

Fuente: Propia

5.3.6 AT+CHTTPSSTART. Este comando es utilizado para adquirir la pila HTTPS, a partir de ahí, ya es posible abrir una sesión con un servidor remoto. En la Tabla 11 se especifica la sintaxis de este comando.

Tabla 11: Sintaxis de comando CHTTPSSTART


AT+ CHTTPSSTART OK ERROR

Fuente: Propia

5.3.7 AT+CHTTPSSTOP. Este comando es utilizado para parar la pila HTTPS y así vaciarla para permitir una nueva sesión. En la Tabla 12 se especifica la sintaxis de este comando.

28

Tabla 12: Sintaxis de comando CHTTPSSTOP


AT+ CHTTPSSTOP OK ERROR

Fuente: Propia

5.3.8 AT+CHTTPSOPSE. Este comando es utilizado para parar abrir una nueva sesión HTTPS. Al abrir la conexión es posible comenzar el envío de información. En la Tabla 13 se especifica la sintaxis de este comando.

Tabla 13: Sintaxis de comando CHTTPSOPSE


AT+CHTTPSOPSE= “<host>”,<port>[, <server_type>]

OK ERROR

Fuente: Propia

En la Tabla 14 se especifica el conjunto de valores que pueden tomar los parámetros de los comandos CHTTPSOPSE definidos en la Tabla 13.

Tabla 14: Valores definidos para CHTTPSOPSE

<host>

La dirección host

<port>

El puerto del host de destino

<server_type>

El tipo de servidor: 1 - Servidor HTTP 2- Servidor HTTPS con SSL3.0/TLS1.0 soportado

Fuente: Propia

29

5.3.9 AT+CHTTPSSEND. Este comando es utilizado para parar enviar una petición HTTPS. El comando AT+CHTTPSSEND=<len> es utilizado para descargar los datos a ser enviados. El comando AT+CHTTPSSEND es utilizado para esperar el resultado del envío. En la Tabla 15 se especifica la sintaxis de este comando.

Tabla 15: Sintaxis de comando CHTTPSSEND


AT+CHTTPSSEND=? +CHTTPSSEND:(1-4096) OK


AT+CHTTPSSEND? +CHTTPSSEND: <unsent_len> OK


AT+CHTTPSSEND=<len> > OK ERROR


AT+CHTTPSSEND OK +CHTTPSEND: <result> ERROR

Fuente: Propia

En la Tabla 16 se especifica el conjunto de valores que pueden tomar las respuestas de los comandos CHTTPSSEND definidos en la Tabla 15.

Tabla 16: Valores definidos para CHTTPSSEND <unset_len>

La longitud de los datos en el buffer de envío el cual es está esperando a ser enviado

<len>

La longitud de los datos a ser enviados

<result>

El resultado final del envío: 0 - ok 1 - error desconocido 2 - ocupado 3 - servidor cerrado 4 - tiempo de espera agotado (timeout) 5 - transferencia fallida 6 - error de memoria 7 - parámetro inválido 8 - error de red

Fuente: Propia

30

5.3.10 AT+CHTTPSRECV. Este comando es utilizado para recibir la respuesta de una petición HTTPS. Permite conocer el tamaño de la respuesta y su posterior recepción. En la Tabla 17 se especifica la sintaxis de este comando.

Tabla 17: Sintaxis de comando CHTTPSRECV


AT+CHTTPSRECV? +CHTTPSRECV: LEN,<cache_len> OK


AT+CHTTPSRECV= <max_recv_len>

OK +CHTTPSRECV: DATA,<len> ... +CHTTPSRECV: DATA,<len> ... +CHTTPSRECV:<result> ERROR

Fuente: Propia

En la Tabla 18 se especifica el conjunto de valores que pueden tomar los parámetros y las respuestas de los comandos CHTTPSRECV definidos en la Tabla 17.

Tabla 18: Valores definidos para CHTTPSRECV

<len>

La longitud de los datos recibidos

<max_recv_len>

El máximo de bytes de datos a recibir durante la llamada actual de +CHTTPSRECV. El valor mínimo es 1

<cache_len>

La longitud del cache

<result>

El resultado final de la recepción 0 - ok 1 - error desconocido 2 - ocupado 3 - servidor cerrado 4 - tiempo de espera agotado (timeout) 5 - transferencia fallida 6 - error de memoria 7 - parámetro inválido 8 - error de red

Fuente: Propia

31

5.3.11 AT+CHTTPSCLSE. Este comando es utilizado para cerrar la sesión HTTPS abierta. En la Tabla 19 se especifica la sintaxis de este comando.

Tabla 19: Sintaxis de comando CHTTPSCLSE


AT+CHTTPSCLSE OK ERROR

Fuente: Propia

32

6. METODOLOGÍA

La implementación y desarrollo de la solución propuesta, es una investigación de tipo experimental-aplicada, por lo tanto, la metodología a utilizar es la investigación aplicada. Esto conduce a la utilización de los conocimientos adquiridos en busca de generar un producto de software.

Con el fin de dar cumplimiento a los objetivos aquí trazados se plantean las siguientes 3 etapas:

Etapa de inicio y recolección: Con base al problema planteado, se adquieren los manuales técnicos del equipo de telefonía celular y se buscan proyectos existentes.

Etapa de configuración y diseño de la aplicación: Se adquiere el hardware necesario con el cual se genera el laboratorio de investigación y pruebas para la solución. Con base a los conocimientos adquiridos y las pruebas realizadas, se crea el diseño de arquitectura de software, metodología de desarrollo y pruebas.

Etapa de desarrollo, pruebas y conclusiones: Se construye la solución de software y se realizan las respectivas pruebas de funcionalidad. Finalmente se obtienen las conclusiones del proyecto realizado. En esta etapa, la metodología a utilizar en el ámbito de Ingeniería de Software y teniendo en cuenta las “metodologías ágiles” [8] (valga la redundancia) se utilizan las historias de usuario cómo base para la especificación de las funcionalidades solicitadas.

33

7. DESARROLLO DEL PROYECTO

Teniendo clara la metodología a utilizar, se determina que el proyecto requiere de una configuración de hardware específica sobre la cual se construye, desarrolla y prueba el software, lo anterior debido a que uno de los objetivos del proyecto es hacer uso de ordenadores miniaturas y móviles (como un Arduino o un Raspberry). Por lo tanto, la primera parte de este punto se enfoca en esta configuración y la segunda en la solución desde el punto de vista del desarrollo de software.

7.1 CONFIGURACIÓN E INSTALACIÓN DEL LABORATORIO

El componente principal de hardware del proyecto y sobre el cual gira la configuración del laboratorio es el módulo de telefonía Adafruit FONA 3G. El resto de componentes y su respectiva función, son detallados en la Tabla 20. Se aclara que la mayoría de estos componentes se pueden adquirir en el sitio web del fabricante.

Tabla 20: Elementos del laboratorio

Elemento Función

Adafruit FONA 3G Módulo celular 3G. Es el componente principal y el que ejecuta las operaciones de telecomunicaciones. (Figura 1)

Batería de litio de 3.7v y al menos 500 mAh

Energiza el módulo de telefonía y le brinda autonomía. (Figura 2)

Antena tipo sticker GSM/Celular Quad-band - 3dBi uFL

Permite al módulo establecer la comunicación con la red de telefonía celular. (Figura 3)

Cable USB a TTL serial para Raspberry Pi

Es el cable que permite la comunicación entre el Raspberry Pi y el módulo de telefonía. (Figura 4)

Raspberry Pi 3 Tendrá el código de la aplicación y ejecutará las instrucciones sobre el FONA 3G. (Figura 5)

Tarjeta SIM compatible 3G La red celular. (verificar la compatibilidad dependiendo de la versión del Adafruit, en el marco teórico de este documento).

Fuente: Propia

34

La siguiente es la lista de las imágenes de referencia para los equipos de hardware mencionados anteriormente:

Figura 1: Módulo Adafruit FONA 3G

Fuente: https://learn.adafruit.com/assets/27347

Figura 2: Batería de Ion litio - 3.7 v 1200 mAh

Fuente: https://www.adafruit.com/product/258

35

Figura 3: Antena tipo sticker


Figura 4: Cable USB a TTL Serial


36

Figura 5: Raspberry Pi 3 modelo B

Fuente: https://www.raspberrypi.org/products/raspberry-pi-3-model-b/

7.1.1 Conexión. Con los elementos de hardware listos y tomando como guía la Figura 6, se realizan las siguientes conexiones:

a) La antena tipo sticker va conectada en la cavidad etiquetada como “Cell ANT”

b) La batería de litio va en el puerto justo al lado de la etiqueta “PWR Key”

c) El cable USB a TTL es conectado siguiendo las siguientes instrucciones:

- Cable blanco al pin etiquetado TX

- Cable verde al pin etiquetado RX

- Cable rojo al pin etiquetado Vio

- Cable negro al pin etiquetado GND

Finalmente se conecta el extremo USB a un puerto libre del Raspberry Pi 3.

37

Figura 6: Conexión Adafruit FONA 3G


Para la conexión por USB a TTL serial, en caso de que no tenga un Raspberry Pi o Arduino, también es posible realizar la conexión directamente desde MAC OS, Windows o Linux [9]

7.1.2 Prueba de conexión. Para poder realizar las pruebas se inserta una tarjeta SIM en el zócalo del reverso del Adafruit Fona. Luego se enciende el módulo de telefonía manteniendo oprimido el botón negro que se encuentra justo debajo de la etiqueta “PWR key” (Figura 6) durante 5 segundos.

38

Enseguida, dos etiquetas “PWR” y “net” que indican unos led, encienden intermitentemente y, a través del Raspberry Pi y utilizando el programa de consola screen, se realiza la prueba conectando al puerto y ejecutando el comando AT básico:

screen /dev/ttyUSB0 115200

AT

Donde ttyUSB0 es el puerto asignado a la conexión con el cable USB a TTL y 115200 es la tasa de baudios por segundo.

A partir de este momento, ya se cuenta con el set de laboratorio listo para iniciar la etapa de investigación empírica sobre el FONA, el diseño y desarrollo de la aplicación. Finalmente se recomienda obtener el IMEI del equipo (utilizando el comando correspondiente que se encuentra en el anexo del manual del SIMCOM) y proceder a ser registrado con el operador celular al que pertenece la tarjeta SIM, para evitar bloqueos por parte de este.

7.2 DESARROLLO DE SOFTWARE

En este capítulo se realiza el proceso de ingeniería relacionado con el desarrollo y programación de la solución requerida.

7.2.1 Historias de usuario. Estas fueron obtenidas a partir de las 3 diferentes entrevistas que se celebraron con los asesores de proyecto de grado, y que en un principio fueron trazados como objetivos específicos. A su vez, debido al tamaño del proyecto, son consideradas como los requisitos que deben ser cumplidos. Lo anterior haciendo claridad, que no fueron utilizadas dentro de iteraciones de SCRUM, como lo indica la teoría.

En la Tabla 21 se encuentran la descripción, criterios de aceptación y características de las historias de usuario.

39

Tabla 21: Historias de usuario Historia de usuario 1

Nombre de la historia: Peticiones HTTP get,post,delete,update

Descripción: Como programador requiero utilizar el módulo del Adafruit Fona 3G, para realizar una petición HTTP con el fin de consumir un servicio JSON-RESTFul y me retorne la respuesta

Criterios de aceptación

1. Verificar que los 4 métodos HTTP: GET, POST, DELETE y UPDATE son ejecutados correctamente 2. Verificar que las peticiones retornen la respuesta del servidor remoto

Historia de usuario 2

Nombre de la historia: Mensajes de texto

Descripción: Como programador requiero obtener en un arreglo todos los mensajes de texto que se encuentran en la línea de telefonía


1. Verificar que el arreglo traiga todos los mensajes


Nombre de la historia: Ejecución de código Python

Descripción: Como programador requiero, a partir de un mensaje de texto, realizar la ejecución del mensaje como código de Python


1. Verificar la ejecución de un mensaje de texto como código nativo


Nombre de la historia: Ejecución de código en el módulo FONA

Descripción: Como programador requiero, a partir de un mensaje de texto, realizar la ejecución del mensaje como código AT en el módulo Adafruit FONA 3G.


1. Verificar la ejecución del mensaje de texto como código en el FONA 2. Obtener la respuesta de la ejecución


Nombre de la historia: Nivel de carga de batería

Descripción: Como programador requiero obtener el porcentaje de nivel de carga de la batería del módulo de telefonía


1. Verificar el nivel de carga de batería


Nombre de la historia: Envío mensaje de texto

Descripción: Como programador requiero un método que me permita enviar un mensaje de texto con base a un número de teléfono y mensaje.

40


1. Verificar el nivel de carga de batería


Nombre de la historia: IMEI del equipo

Descripción: Como programador requiero un método que me devuelva el IMEI del módulo de telefonía.


1. Verificar el IMEI


Nombre de la historia: Reinicio del módulo

Descripción: Como programador requiero un método que me permita reiniciar bien sea el módulo o la conexión con el módulo (puerto)


1. Ejecutar el comando y verificar que efectivamente se reinició el equipo

Fuente: Propia

7.2.2 Diagrama de clases. Se establece una clase principal llamada Pyfona como la responsable e implementación de las características objetivos del proyecto. Esta, hace uso de una clase auxiliar (PyfonaHelper), una clase encargada de la comunicación y configuración del puerto serial (PuertoSerial) y finalmente otra clase auxiliar de escritura de logs (Logger), En la Figura 7 se puede observar la relación entre las clases con sus respectivas variables y métodos:

41

Figura 7: Diagrama de clases

Fuente: Propia basada en los requerimientos de software usando UML.

42

Debido a que la funcionalidad deseada es similar a una librería sobre la cual se extienda una capa adicional con responsabilidades diferentes, no es posible considerar diseñar una solución que en su arquitectura se contemplen varias capas. Por lo tanto la solución utiliza una sola capa y no genera dependencias externas a librerías no incluidas dentro del paquete básico de Python 2.7. Las siguientes son las descripciones de las clases del proyecto y sus respectivos métodos:

a. Pyfona: Clase principal del programa que permite hacer uso de las funcionalidades declaradas en las historias de usuario:

__init__() : Constructor de la clase. Configura la conexión sobre el puerto serial y prueba un comando sencillo sobre el Adafruit FONA 3G.

enviarPeticionHTTP(url, metodo, data) : Permite enviar a un destino, especificando el método HTTP y los datos para los casos POST y UPDATE, una petición.

enviarMensajeTexto(numero, mensaje): Realiza el envío de un mensaje de texto.

leerTodosMensajesTexto(): Devuelve el arreglo con los identificadores, fecha y mensajes de texto recibidos.

ejecutarCodigoPython(idsms): Ejecuta la cadena del mensaje de texto con el identificador enviado, en lenguaje Python

ejecutarCodigoModuloFona(idsms): Ejecuta la cadena del mensaje de texto con el identificador enviado, en el Adafruit FONA como si fuera un comando AT.

chequearEstadoBatería(): Devuelve el estado de la batería del módulo de telefonía

obtenerIMEI(): Retorna la cadena del IMEI de Adafruit FONA

reiniciarModuloFona(): Fuerza el reinicio del módulo de telefonía

43

b. PyfonaHelper: Es una clase auxiliar que ejecuta principalmente las ejecuciones en el módulo de telefonía y además presta funciones de ayuda.

ejecutarComandoAT(tout,log,command,stringesperado): Ejecuta un comando AT utilizando la conexión con el puerto serial hacia el FONA. El resultado es almacenado en una variable de la clase

obtenerResultadoEjecucion(): Retorna el resultado de la ejecución del método anterior

validarURL(url): Analiza mediante una expresión regular, la

composición de la URL que va a ser utilizada.

splitURL(url): Retorna las tuplas de los elementos de la URL.

cadenaMultiArreglo(cadena): Convierte los mensajes de texto multilínea en un arreglo bidimensional ordenado.

c. PuertoSerial: Esta clase se encarga de la configuración y comunicación

con el puerto serial. Cada vez que se va a ejecutar un comando AT, esta clase se encarga de limpiar el buffer y gestionar el envío de información.

obtenerSerial(): Retorna la instancia de la clase para ser utilizada

d. Logger: Se encarga del manejo y escritura del archivo de registro de la aplicación.

obtenerLogger(): Retorna la instancia de la clase para ser utilizada

7.2.3 Flujo de Comandos para una petición HTTP. En el siguiente diagrama se especifica el orden de comandos AT que se ejecutan en la funcionalidad de una petición HTTP, desde que se configura el contexto PDP hasta recibir la respuesta del servidor remoto. Este proceso cumple con las llamadas a servicios JSON-RESTFul y los 4 métodos HTTP solicitados por el usuario. En la Figura 8 se detalla todo el flujo de comandos para una petición HTTP.

44

Figura 8: Diagrama de Flujo de componentes

Fuente: Propia basada en el flujo de comandos del manual del chip SIM5320A

45

7.3 PRUEBAS En este capítulo se realiza el conjunto de pruebas de software y funcionalidad de cada una de las características abstraídas e implementadas en el proyecto. Para su entendimiento, se muestra a continuación la ejecución del proyecto sobre el Raspberry Pi 3 y su respectiva consola de Python, la instanciación de la clase Pyfona (clase principal del proyecto) y los ejemplos de uso de cada una de las funciones de la librería. Como primer paso, se navega utilizando la consola de comandos (bash) del Raspberry hasta el proyecto y se ingresa a la carpeta src. En seguida se ejecuta la consola intérprete de Python, como lo muestran los siguientes comandos: pi@raspberrypi:~/pyfona/src $ python

Python 2.7.13 (default, Jan 19 2017, 14:48:08)

[GCC 6.3.0 20170124] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>>

Una vez dentro, se importa e instancia la clase de acuerdo al APN del proveedor de telefonía celular que este: >>> import Pyfona as myPyfona

>>>

>>> APN = "lte.avantel.com.co"

>>> debug = True

>>> myPyfona = myPyfona.Pyfona(apn_url=APN,nivelLog=debug)

Adicionalmente el objeto es instanciado con el nivel de log en True para activar el debug. El archivo de log (por defecto: logs/pyfona-app.log) almacenará la traza de las peticiones. Una vez se instancia la clase myPyfona se inicia el ciclo de pruebas tal como se muestra en las siguientes secciones:

7.3.1 Enviar petición HTTP. Para realizar esta prueba, se hace una petición HTTP GET a un sitio web que cuenta con servicios JSON-REST publicados en internet. El sitio web es: http://dummy.restapiexample.com y como indica este sitio, se hace la petición para obtener el employee con ID=3: >>> URL_GET = "http://dummy.restapiexample.com/api/v1/employee/3"

>>> myPyfona.enviarPeticionHTTP(URL_GET,"GET",None)

>>> URL_GET = "http://dummy.restapiexample.com/api/v1/employee/3"

>>> resp = myPyfona.enviarPeticionHTTP(URL_GET,"GET",None)

46

>>> print resp

+CHTTPSRECV: DATA,671

HTTP/1.1 200 OK

Server: nginx/1.12.2

Date: Sun, 06 May 2018 20:59:22 GMT

Content-Type: text/html; charset=UTF-8

Transfer-Encoding: chunked

Connection: keep-alive

Expires: Thu, 19 Nov 1981 08:52:00 GMT

Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0

Pragma: no-cache

Access-Control-Allow-Origin: *

Access-Control-Expose-Headers: Content-Type, X-Requested-With, X-authentication, X-client

Set-Cookie: PHPSESSID=nb7tdhr6bgsne85nd8jcvdrkc1; path=/

Vary: Accept-Encoding

X-Acc-Exp: 0

X-Proxy-Cache: MISS dummy.restapiexample.com

59

{"id":"3", "employee_name":"James Brown", "employee_salary":"3500", "employee_age":"42",

"profile_image":""}

0

+CHTTPSRECV: 0

En el mensaje de respuesta se encuentra la respuesta con formato JSON en el cuerpo del mensaje: {

"id":"3",

"employee_name":"James Brow",

"employee_salary":"3500",

"employee_age":"42",

"profile_image":""

}

7.3.2 Obtener la lista de mensajes de texto. Esta función obtiene los mensajes de texto (SMS) disponibles en el equipo y son devueltos en una lista. La lista contiene un arreglo por cada mensaje recibido con la estructura de la Tabla 22. Esta es la prueba técnica del uso de este método: >>> mensajes = myPyfona.leerTodosMensajesTexto()

>>> type(mensajes)

<type 'list'>

>>> print mensajes

[[0, '"REC READ"', '"40405"', '"17/07/05 10:50:41-16"', 'GMLaunch: Get GMLaunch Alerts sent

to your mobile device. Up to 2msgs/wk. Reply STOP to stop messages. Email [email protected] for

more info.'],

[1, '"REC READ"', '"+573175050342"', '"18/04/17 23:17:44-20"', 'Mensaje de prueba 1'],

[2, '"REC READ"', '"3104094131"', '"17/09/21 21:45:54-20"', 'mensaje de prueba 2'],

[3, '"REC READ"', '"3104094131"', '"17/09/21 21:45:54-20"', 'mensaje de prueba 3']]

47

Tabla 22: Estructura del arreglo del mensaje

Id Estado Remitente Fecha Mensaje

1 REC READ +573175050342 18/04/17 23:17:44-20 Mensaje de prueba 1

Fuente: Propia

7.3.3 Ejecutar mensaje en Python. Permite ejecutar códigos en Python a partir de un identificador de un mensaje de texto. En el ejemplo, se obtiene la lista de mensajes de texto y se ejecuta el mensaje de texto con identificador 35 >>> mensajes = myPyfona.leerTodosMensajesTexto()

>>> print mensajes

.

.

.

[[35, '"REC READ"', '"+573166275469"', '"18/04/06 22:27:40-20"', 'import sys; print

sys.version']]

>>> resultado = myPyfona.ejecutarMensajeEnPython(35)

>>> print resultado

2.7.13 (default, Jan 19 2017, 14:48:08)

[GCC 6.3.0 20170124]

7.3.4 Ejecutar mensaje en FONA. Permite ejecutar códigos en el módulo de FONA a

partir de un identificador de un mensaje de texto. En el ejemplo, se obtiene la lista de mensajes de texto y se ejecuta el mensaje de texto con identificador 36 >>> mensajes = myPyfona.leerTodosMensajesTexto()

>>> print mensajes

[[35, '"REC READ"', '"+573166275469"', '"18/04/06 22:27:40-20"', 'import sys; print

sys.version'],

[36, '"REC READ"', '"+573166275469"', '"18/04/06 22:42:15-20"', 'AT+COPS?']]

>>> respuesta = myPyfona.ejecutarMensajeEnFona(36)

>>> print respuesta

AT+COPS?

+COPS: 0,0,"Movistar",2

OK

7.3.5 Enviar mensaje de texto. Realiza el envío de un mensaje de texto utilizando el módulo del FONA mediante las instrucciones que se muestran a continuación: >>> mensaje = "Hola mundo"

>>> destinatario = "3166275469"

>>> myPyfona.enviarMensajeTexto(destinatario,mensaje)

'\r\n\r\n+CMGS: 5\r\n\r\nOK\r\n'

48

Se revisa el log en nivel de debug de la ejecución anterior y se puede ver el detalle del envío: 2018-05-07 04:06:42,680 - Logger - INFO - Inicio envío de mensaje de texto: 3166275469 -

Hola mundo

2018-04-07 04:06:42,681 - Logger - DEBUG - Comando enviado: AT+CMGF=1

2018-04-07 04:06:43,685 - Logger - DEBUG - Respuesta: (12) AT+CMGF=1

2018-04-07 04:06:43,686 - Logger - DEBUG - Respuesta: (4) OK

2018-04-07 04:06:43,687 - Logger - DEBUG - Comando enviado: AT+CMGS="3166275469"

2018-04-07 04:06:44,692 - Logger - DEBUG - Respuesta: (23) AT+CMGS="3166275469"

2018-04-07 04:06:45,694 - Logger - DEBUG - Respuesta: (2) >

2018-04-07 04:06:45,696 - Logger - DEBUG - Comando enviado: Hola mundo▒

2018-04-07 04:06:46,698 - Logger - DEBUG - Respuesta: (2)



2018-04-07 04:06:48,613 - Logger - DEBUG - Respuesta: (10) +CMGS: 5


2018-04-07 04:06:48,614 - Logger - DEBUG - Respuesta: (4) OK

Por último, en la Figura 9 se muestra la evidencia de recepción de mensaje desde el equipo destino.

Figura 9: Recepción del sms

Fuente: Propia basada en las pruebas realizadas.

7.3.6 Leer mensaje de texto. Retorna un solo mensaje de texto de acuerdo al identificador enviado. >>> myPyfona.leerMensajeTexto(36)

'AT+COPS?'

49

7.3.7 Obtener el estado de la batería. Permite conocer el estado de la batería del módulo de telefonía. >>> myPyfona.estadoBateria()

'AT+CBC\r\r\n+CBC: 0,68,3.894V\r\n\r\nOK\r\n'

7.3.8 Obtener el IMEI del módulo FONA. Retorna la información del IMEI y registro del equipo Adafruit FONA 3G >>> myPyfona.obtenerIMEI()

'ATI\r\r\nManufacturer: SIMCOM INCORPORATED\r\nModel: SIMCOM_SIM5320A\r\nRevision:

SIM5320A_V1.5\r\nIMEI: 014682000799790\r\n+GCAP: +CGSM,+DS,+ES\r\n\r\nOK\r\n'

50

8. CONCLUSIONES Los resultados del presente proyecto son fruto de una metodología investigativa aplicada, la cual a partir de la información recolectada, los manuales técnicos del módulo de telefonía Adafruit FONA 3G y los conocimientos en tecnologías de la información adquiridos durante los años de estudio y experiencia profesional. Por lo tanto, los siguientes son las conclusiones del trabajo realizado:

La librería desarrollada durante el presente proyecto Pyfona, representa la interfaz propuesta de la abstracción de las funcionalidades trazadas en los objetivos del documento, tales como el envío de peticiones HTTP para consumir servicios JSON, ejecución de códigos a partir de mensajes de texto, entre otros.

El lenguaje utilizado durante el desarrollo (natural e intuitivo) y el lenguaje de programación Python, facilitan la comprensión del código programado para así permitir, una fácil implementación y uso, en proyectos de mayor envergadura.

De manera satisfactoria se concluyen las características técnicas y su respectivo ciclo de pruebas, con la intención de probar la calidad y ejecución de las funcionalidades propuestas. Con este paso realizado, se busca que este producto de software se convierta en un marco de trabajo para el proyecto de ciudades y espacios inteligentes.

51

9. TRABAJO FUTURO Es posible que el trabajo realizado pueda ser adaptado a otro módulo Adafruit Fona. Para esto es necesario verificar la compatibilidad de los comandos AT que son ejecutados. Se recomendaría crear una clase que herede de la actual y sobre escriba los comandos de acuerdo a la nueva documentación técnica. Adicionalmente, aún existen funcionalidades que podrían ampliar el dominio de funciones del proyecto acá presentado, por ejemplo:

Enviar llamadas (y utilizar el micrófono para enviar el sonido capturado)

Recibir llamadas (funciones de audio y volumen)

Obtener la ubicación

Obtener el estado de la batería

Desbloqueo de simcard con pin

Obtener la hora

Borrar mensajes de texto Por último, es importante construir una capa lógica de aplicación por encima que permita la ejecución de estas funcionalidades bien sea de manera remota o autónoma.

52

BIBLIOGRAFÍA Ada, L. (2018). Overview. Consultado el 20 de Abril de 2018 de https://learn.adafruit.com/adafruit-fona-3g-cellular-gps-breakout/overview. Ada, L. (2018). Adafruit FONA 3G Cellular + GPS Breakout. Consultado el 20 de Abril de 2018 de https://cdn-learn.adafruit.com/downloads/pdf/adafruit-fona-3g-cellular-gps-breakout.pdf. IBM (2018). RESTful web services. Consultado el 20 de Abril de 2018 de https://www.ibm.com/support/knowledgecenter/en/SSGMCP_5.2.0/com.ibm.cics.ts.webservices.doc/concepts/concepts_restful.html. Copyright © Shanghai SIMCom Wireless Solutions Ltd. (2013). AT Command Set SIMCOM_SIM5320_ATC_EN_V2.02. Consultado el 20 de Abril de 2018 de http://www.adafruit.com/datasheets/SIMCOM_SIM5320_ATC_EN_V2.02.pdf Canós, J. H., Letelier, P y Penadés, M. C. (2018). Metodologías Ágiles en el Desarrollo de Software. Consultado el 20 de Abril de 2018 de http://roa.ult.edu.cu/jspui/bitstream/123456789/476/1/TodoAgil.pdf

Vargas, Z. R. (2009). LA INVESTIGACIÓN APLICADA: UNA FORMA DE CONOCER LAS REALIDADES CON EVIDENCIA CIENTÍFICA. Consultado el 20 de Abril de 2018 de http://www.redalyc.org/pdf/440/44015082010.pdf

53

LISTA DE REFERENCIAS

[1] Ministerio de Tecnologías de la Información y las Comunicaciones. Departamento Nacional de Planeación DNP Política de Tecnologías de la Información y las Comunicaciones para Ciudades y/o Territorios Inteligentes. Recurso disponible en línea. http://centrodeinnovacion.gobiernoenlinea.gov.co/sites/default/files/documento_base_politica_de_ciudades_inteligentes.docx.

[2] Ministerio de Tecnologías de la Información y las Comunicaciones. Departamento Nacional de Planeación DNP Política de Tecnologías de la Información y las Comunicaciones para Ciudades y/o Territorios Inteligentes. Recurso disponible en línea. http://centrodeinnovacion.gobiernoenlinea.gov.co/sites/default/files/documento_base_politica_de_ciudades_inteligentes.docx (página 15).

[3] Que son los comandos Hayes. Recurso disponible [en línea]. https://www.lammertbies.nl/comm/info/hayes-at-commands.html (Enlace existente 20/04/2018).

[4] Limor Fried/Ladyada. Recurso disponible [en línea]. https://github.com/adafruit/Adafruit_FONA/blob/master/Adafruit_FONA.h (commit 86d783a de Agosto 29 de 2017, Branch Master, Tag: 1.3.4).

[5] Recurso disponible [en línea]. https://learn.adafruit.com/adafruit-fona-mini-gsm-gprs-cellular-phone-module/wiring-to-usb.

[6] vshymanskyy. Recurso disponible [en línea]. https://github.com/vshymanskyy/TinyGSM (commit 6340b60 de Abril 29 de 2018, Branch Master).

[7] Guía de Territorios y Ciudades Inteligentes. Observatorio de Sociedad, Gobierno y Tecnologías de Información. Universidad Externado de Colombia. 2013.

http://centrodeinnovacion.gobiernoenlinea.gov.co/sites/default/files/documento_base_politica_de_ciudades_inteligentes.docx




https://www.lammertbies.nl/comm/info/hayes-at-commands.html

https://github.com/adafruit/Adafruit_FONA/blob/master/Adafruit_FONA.h

https://learn.adafruit.com/adafruit-fona-mini-gsm-gprs-cellular-phone-module/wiring-to-usb

https://learn.adafruit.com/adafruit-fona-mini-gsm-gprs-cellular-phone-module/wiring-to-usb

https://github.com/vshymanskyy/TinyGSM

54

[8] Canós, J. H., Letelier, P y Penadés, M. C. (2018). Metodologías Ágiles en el Desarrollo de Software. Consultado el 20 de Abril de 2018 de http://roa.ult.edu.cu/jspui/bitstream/123456789/476/1/TodoAgil.pdf

[9] Ada, L. (2018). Installing FTDI Drivers. Consultado el 20 de Abril de 2018 de https://learn.adafruit.com/ftdi-friend/installing-ftdi-drivers.

http://roa.ult.edu.cu/jspui/bitstream/123456789/476/1/TodoAgil.pdf

https://learn.adafruit.com/ftdi-friend/installing-ftdi-drivers

DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE ...

Documents

Transcript of DESARROLLO DE LIBRERÍA EN PYTHON PARA CONTROL DE ...