Recursos para la utilización del puerto serie en entornos ... · Abstract El siguiente trabajo es...

Diplomatura en Software Libre

Universidad del Este

La Plata - Argentina

Recursos para la utilización del

puerto serie

en entornos GNU/Linux

Diego Codevilladiegocodevilla.com.ar

Docente: Mariano Reingart

Esta obra está bajo una Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional.

Abstract

El siguiente trabajo es una recopilación de información y aplicaciones, para facilitar la utilización del puerto serie bajo entornos GNU/Linux, y siempre que sea posible, en otros sistemas operativos.

El material tiene una fuerte impronta hacia principiantes, educación y economía en recursos.

Se ha desarrollado una aplicación que permite a personas sin conocimientos de programación realizar un sistema de monitoreo y control sencillo, una terminal orientada a adquisición de datos y trabajo con sistemas embebidos, y una utilidad de diagnóstico.

La producción también incluye material de referencia y ejemplos de uso.

1

a. Objetivos

El objetivo de este trabajo es producir material de referencia y aprendizaje, ejemplos para utilizar el puerto

serie en ambientes GNU/Linux / Unix, y otros sistemas, para referencia de alumnos de colegios técnicos, y la

comunidad en general. Y aplicaciones que sean útiles para sacar provecho de este recurso.

Siempre que sea posible, el material se podrá utilizar en otros sistemas.

b. Motivación

¿Por qué el puerto serie?

Aunque hace años es una interfaz que desapareció de las computadoras de escritorio y portátiles es una

tecnología muy utilizada y vigente en áreas específicas: industria, control y adquisición de datos, electrónica,

redes, y se la utiliza para comunicaciones con sistemas embebidos, microcontroladores, PLC, sensores,

controladores y medidores dedicados, GPS, modems, instrumental, etc.

¿Por qué en ambientes GNU/Linux?

Dejando de lado convicciones personales, actualmente en las áreas mencionadas (y en muchas otras)

GNU/Linux está consolidado como producto de primer nivel y aumentando su cuota de mercado (más del

60%)1 2

Además, es un mercado en expansión: avance de la IoT, computadoras económicas como las Raspberry Pi,

amplia aceptación de Arduino en diversas áreas (no solo técnicas)

Otra motivación importante para el presente trabajo es la posibilidad que brinda GNU/Linux y un puerto serie

de aprovechar máquinas obsoletas (Ej. netbooks con procesadores Atom) o de bajo costo (muchos nuevos

modelos basadas en ARM) como herramientas de aprendizaje, prototipado, adquisición y control en general.

¿Por qué tanta relevancia a las líneas de handshaking?

En el presente trabajo se le da gran protagonismo a las líneas de handshaking. El autor, en su tarea docente,

apreció como su utilización representó un recurso beneficioso para afianzar conceptos de programación (el

alumno “ve” lo que programa, sale de lo totalmente abstracto), para poner en práctica el desarrollo de

circuitos de interfaz, para incorporar conceptos importantes (pines de entrada, de salida, máscaras) práctica

informal de maquinas de estados, etc. (ver Trabajos Prácticos realizados)

Además, y ampliando esta experiencia, resulta interesante poder usar las líneas de handshaking para las

primeras incursiones en control y adquisición de datos, máquinas de estado, interfaces, lógica, hobbies,

instalaciones artísticas, etc. ya que con un adaptador USB – serie es un método económico, y robusto en

comparación con sistemas basados en microcontroladores (Arduino – Atmel, PIC, etc.) es mucho más

1 https://www.linux.com/news/embedded-mobile/mobile-linux/818011-embedded-linux-keeps-growing-amid-iot-disruption-says-study,

2. http://www.pcworld.com/article/2868399/why-2015-is-the-year-of-linux-on-the-everything-but-desktop.html

2

robusto: “aguantan” peores maltratos (ej. el estándar 232 indica manejo de cortocircuitos entre cualquiera de

sus patas)

Permiten un uso “paralelo” del puerto serie y de forma muy simple brindan excelentes posibilidades en

educación, hobbies, prototipos, etc.

Este lugar era ocupado por el puerto paralelo, que tenía mayor cantidad de entradas y salidas, era más

simple e intuitivo para programar y trabajar. A pesar del desuso en que ha caído este puerto, actualmente

existen proyectos que permiten trabajar con el puerto paralelo en diversos lenguajes (Python, C, etc.) pero no

ofrecen buen soporte (o directamente no soportan) adaptadores USB-Paralelo por lo que su uso actual se

redujo notablemente.

c. Recursos

En las aplicaciones y ejemplos, y referencia en general, al ser pensado para uso en dispositivos poco

potentes y por personas sin demasiada experiencia previa se eligieron tecnologías pensando en su sencillez

de aprendizaje y economía de recursos computacionales.

Como lenguaje de desarrollo de herramientas se utilizó Python, y la librería PySerial. También en este

lenguaje se realizaron los ejemplos de uso para complemento del material teórico.

Como recurso extra en los ejemplos, en algunos test para desarrollo y prueba de aplicaciones, se utilizó un

Arduino Uno y diversos componentes electrónicos adicionales.

d. Panorama actual

¿Qué existe?

En cuanto a aplicaciones con puerto serie tenemos una categoría importante: los programas “terminal”

Existen excelentes aplicaciones para ambientes windows:

- RealTerm (http://realterm.sourceforge.net/)

- Bray++ Terminal (https://sites.google.com/site/terminalbpp/)

- Hercules. (http://www.hw-group.com/products/hercules/index_en.html)

Para GNU/Linux, sin embargo, no existen programas tan completos. Algunos de los disponibles:

- CoolTerm (http://freeware.the-meiers.org/)

- GtkTerm (https://fedorahosted.org/gtkterm/)

- CuteCom (http://cutecom.sourceforge.net/ la última versión es del 2009)

- Hterm (http://www.der-hammer.info/terminal/ última versión de 2008),

El aprovechamiento de las líneas de handshaking como entrada-salida de uso general, no se observa en

ningún producto (excepto en los productos para windows, y solo en modo “manual”)

3

e. Organización del proyecto

El proyecto se compone de tres partes:

1. Material teórico:

Un conjunto de documentos de referencia y educativos realizados principalmente con formato de

presentación, que cubren:

- Aspectos de hardware

- Aspectos de software

- Circuitos de aplicación útiles

- Ejemplos sencillos de hardware y software

2. Aplicaciones completas que sirvan como herramientas reales y ejemplos completos:

- Una utilidad de diagnóstico

- Una aplicación completa de control y monitoreo con e-s digitales

- Una aplicación terminal con la meta de mejorar, en el futuro, las existentes para GNU/Linux

3. Un ejemplo en la forma de un sistema de adquisición de datos como aplicación concreta y para mostrar

posibles integraciones con otras herramientas (web, bases de datos)

En concreto se trata de un visualizador de temperatura y humedad que se obtienen con un sistema remoto de

sensado.

f. Acceso al material

Para permitir el acceso público a este material y eventuales colaboraciones :

- github (https://github.com/diegocode/serie) – código (aplicaciones y ejemplos)

- web (http://www.diegocodevilla.com.ar/serie) – material de referencia, aplicaciones, ejemplos

g. Tecnologías

Se utilizaron muchas herramientas para el desarrollo del presente trabajo.

La plataforma de hardware para desarrollo fue una notebook Asus K53E i3-2350 - 8 Gb y Linux Mint 17.1 KDE

4

Para pruebas se utilizó la misma computadora con el mismo sistema operativo y con Windows 7 64b Home,

una netbook LG-X110 (Atom N270 – 1Gb) con Windows 7 32b Home, una Netbook Asus 1005HA (Atom N270

– 2Gb) con Debian 8.2 + xfce y Windows XP Home, y una Desktop Sempron 2200+ Mother M7VIG400, 1Gb

con Windows XP

Software más relevante:

Editor

• Kate + plugins varios

Lenguajes

• Python 2.7 • C++• Para WEB: HTML, PHP, JavaScript (Stack LAMPP local y remoto)

Librerías

• PySerial

• request• argparse• time• sys

GUI

• tkinter• wxWidgets • Qt

Herramientas de creación de GUI

• wxGlade• QtCreator* (Es un IDE completo)

Material de referencia y estudio, diagramas, documentación:

• LibreOffice Impress, Writer, Calc, Draw

• Google docs: Hojas de cálculo: para planillas de scrum

• Pencil: bocetos de GUI, diagramas

• Gimp: edición de imagenes

• Umbrello: UML

• Fritzing, Eagle**: Dibujo de circuitos electrónicos y esquemáticos.

Embebidos

• Arduino

*QtCreator se utilizó la versión Community

**Eagle (es comercial. Se utilizó la versión Freeware)

5

Se utilizó software libre, excepto Eagle.

h. Planificación

El material se desarrolló utilizando una mixtura de Scrum para la planificación general, XP / TDD para el

desarrollo de aplicaciones; sumado a una técnica de manejo personal de tiempos (Pomodoro:

http://pomodorotechnique.com/ )

Esta combinación ha dado muy buenos resultados en proyectos (unipersonales) anteriores:

Luego de un período inicial de investigación, recopilación de información, revisión de material, se confeccionó

un primer “sprint” y se comenzó el desarrollo en sí.

Se usaron sprints de una semana, con historias acotadas, aprovechando que este proyecto permite alta

granularidad, lográndose un ritmo de trabajo agradable con gran porcentaje de cumplimiento de lo planificado.

Para presupuestar el tiempo se utilizaron “unidades de trabajo” / “UT”, que en mi caso, y por experiencias

previas, se corresponden con unos 45-50 minutos, separados como mínimo por intervalos de 15 minutos.

En promedio se le dedicaron 4 UT por día.

(Sprints en planilla (en github) o en Google Docs: https://docs.google.com/spreadsheets/d/1bWmN2ZUkDPlnvU_0oodfvnf0uN5KucH-

bi7tqNMZuSY/edit?usp=sharing)

al 23.01

6

al 30.01

al 06.02

al 13.02

7

i. Resultados

Los resultados completos (fuentes, documentación, ejemplos) así como videos mostrando las

aplicaciones en funcionamiento se encuentran en:

http://www.diegocodevilla.com.ar/serie

1. Material de referencia y estudio

Disponible en el site indicado, y en el repositorio github, es un documento realizado en forma de presentación,

pensado tanto para referencia y estudio personal como para asistir en el desarrollo de exposiciones sobre el

tema.

Además se adjuntan los ejemplos que se muestran en el documento.

También, como anexo, se realizó una guía de uso y un ejemplo de transmisión y recepción en Qt y C++

2. Las aplicaciones realizadas

sloopback

Es un programa simple y útil.

Permite testear una conexión serie.

Envía un string y verifica recibir exactamente lo mismo dentro de un tiempo de timeout.

Si se recibe el mensaje con error o se produce timeout informa un error.

Además es capaz de listar los puertos serie disponibles.

Es un programa que se ejecuta en consola y recibe los siguientes argumentos:

-h, --help

-v, --version

-p, --port=PORT especifica el por a usar (ej.: '/dev/tty0' 'COM7')

-m, --message=MESSAGE el string para usar en las pruebas

-t, --timeout=FLOAT timeout máximo en segundos (Ej. 0.25 → 250ms)

-l, --list lista los puertos disponibles (y termina el programa)

-q, --quiet solo muestra en pantalla los errores

8

Si hay respuesta y esta no es igual al string enviado, se muestra lo recibido.

Puede servir para enviar cualquier string por un puerto determinado, más allá de que haya o no respuesta (Ej.

para probar cómo se comporta un dispositivo al recibir un mje. y cuál es su respuesta)

Se usaron:

- pyserial para el manejo del port serie

- argparse para trabajar con los argumentos pasados al programa

- sys para capturar Ctrl+C de forma elegante y para terminar el programa con mensaje e estado al SO:

sys.exit(n)

sloopback.py -q solo errores; el mensaje default es una D

Recibido con y sin errores. Mensaje pasado por línea de comandos.

9

Ayuda y listado de puertos disponibles.

sloopback en windows 7

10

controldig

Es un programa que permite monitorear el estado de las seis líneas de handshaking (CD, RI, DSR, CTS, DTR

y RTS) de un puerto serie, y fijar el estado de RTS y DTR (que son las salidas)

Permite fijar los estados de las dos salidas en forma manual, o de acuerdo a un “script” que describe una

máquina de estados (de Moore) simple.

De esta manera, es posible realizar un sistema de control on-off sencillo sin saber programar.

Es posible asignar nombres descriptivos a cada una de las patas del port (Ej. “sensor de luz” en lugar de

DSR)

Guarda los estados en un archivo de texto (un registro de eventos) con marca temporal opcional.

Desde el teclado se pueden utilizar en forma interactiva los siguientes comandos:

d - se detiene el refresco periódico del estado de e / s

r - reinicia el refresco periódico del estado de e / s

s - muestra el estado de las e / s

sr - set RTS

rr - reset RTS

sd - set DTR

rd - reset DTR

x - finaliza el programa

La configuración del programa se determina con un archivo de texto.

Actualmente las opciones de configuración disponibles son:

tscan: cada cuántos segundos se verifica el estado de las entradas y se cambia el estado de las salidas de

acuerdo al script especificado (en modo automático)

nombres: un diccionario que permite asignar nombres a las patas del puerto.

puerto: el nombre de puerto serie a utilizar

archivo_estados: el archivo donde se especifica el script o la máquina de estados para el modo

automático

estado_inicial: de los estados definidos en el script, cuál es el inicial

archivo_registro: archivo donde se guarda el registro de eventos. Si no se especifica no se genera

11

registro.

registro_solo_cambios: dtermina si se guarda una línea cada tscan o solamente cuando haya algún

cambio en las patas.

registro_fecha / registro_hora: si se agrega fecha / hora a cada línea del archivo de registro.

registro_separador: carácter para separar los campos en cada línea del archivo de registro.

Ejemplo de archivo de configuración:

tscan = 2

nombres={"DCD": "DCD", "RI":"RI", "DSR":"DSR", "CTS":"CTS", "RTS":"RTS", "DTR":

"DTR"}

puerto = /dev/ttyUSB0

archivo_estados = prueba.scd

estado_inicial = 002

archivo_registro=eventos.log

registro_solo_cambios=1

registro_fecha=1

registro_hora=0

registro_separador=;

Un ejemplo de archivo de script:

003,11,0001:02,0010:3

000,10,0001:0000,0010:3

002,01,0010:0002,0110:0

Estructura:

nro. estado, DTR RTS, CD RI DSR CTS:estado destino,DTR CTS, CD RI DSR CTS:estado destino

Las tres líneas del script de ejemplo anterior definen la siguiente máquina de estados (el estado inicial es el

estado 2, especificado en el archivo de configuración del ejemplo)

12

Las transiciones se especifican en el siguente orden: CD RI DSR CTS

Los estados: DTR RTS

Ejecución mostrando la salida por pantalla, y diversos comandos interactivos: d, r, rr, sr, rd, sd, x

Para permitir el ingreso desde teclado y a la vez poder realizar el muestreo de estado, registro, y

visualización, se investigó sobre threads, y se creó una clase Timer (que fue luego utilizada en dcterminal y

algunos ejemplos) Si bien esto provocó un retraso imprevisto, el resultado fue muy interesante y útil y se pudo

conocer sobre el manejo de Threads en Python.

Otras clases que se desarrollaron para este proyecto (y en el caso de las dos primeras se reutilizaron para

dcterminal)

• Configuracion

• Registrador

• Estado

13

También se comenzó a desarrollar una GUI con wxWidgets que se ejecuta “sobre” la versión de línea de

comandos. A la fecha de presentación faltan completar algunas funcionalidades pero refleja correctamente el

estado de las entradas y salidas y permite alterar estas últimas. También muestra la configuración

determinada por el archivo .cfg descripto más arriba.

Controldig-gui en KDE (Mint 17.1)

14

Controldig-gui en Windows 7

Controldig en Windows 7

15

dcterm

El objetivo, como ya se ha comentado, es desarrollar un programa terminal útil, un poco más complejo que los

existentes para GNU/Linux, para que no se sienta tanto la falta de programas excelentes para windows:

RealTerm, Hercules y Bpp+ Terminal.

Lo desarrollado actualmente es un programa que permite enviar datos por el puerto serie y visualizar los

datos que recibidos en ASCII, hexadecimal y binario.

Además permite especificar un archivo que funciona como registro (funcionalidades similares al programa

anterior, ya que la clase utilizada es la misma: Registrador)

Es posible indicar un inicio y offset para tomar de una línea recibida un segmento:

Ej. si se recibe “Temp: 28.00 C” especificando inicio = 6, fin = 10, se visualiza, registra, etc. “28.00” solamente.

También, mediante la librería request se incorporó la posibilidad de especificar una url y qué datos enviarle:

ej. si se indica http://www.diegocodevilla.com.ar/serie/clima/recibe.php y datos, el programa envía

http://www.diegocodevilla.com.ar/serie/clima/recibe.php?datos=datos

De esta manera es muy sencillo implementar un sistema de adquisición de datos remoto. O una visualización

de datos web (local o remota)

- Prueba de transmisión y recepción:

Se envía un carácter numérico (entre 0 y 9) y se recibe esa cantidad de asteriscos. Se utiliza un Arduino

conectado a la computadora, con el programa que se indica:

/*Programa de Arduino para prueba tx-rx

Envia la cantidad de asteriscosespecificada por el caracter ascii recibidoEj. recibe '6' enva '******' */

16

void setup(){ // initialize the serial communication: Serial.begin(9600);}

void loop() { unsigned char car; // check if data has been sent from the computer: if (Serial.available()) { car = Serial.read(); for (int i = 0; i < car - 0x30; i++) { Serial.write("*"); } Serial.write( "\n"); }}

- Prueba de transmisión y recepción:

Se muestra en pantalla una secuencia de números en hexadecimal, que expresan los caracteres recibidos de

un Arduino. Estos caracteres representan el valor de la conversión del ADC del Arduino conectado a un preset

como se muestra (0 → 0V, 1023 → 5V)

Ej. El primer valor que se muestra en la imagen es: 534 (ASCII 0x35, 0x33, 0x34) 0x0D y 0x0A corresponden

al fin de línea.

/*

envia por puerto serie el valor de conversion

de un ADC - pata AI 0

*/

void setup() {

// initialize the serial communication:

17

Serial.begin(9600);

}

void loop() {

// send the value of analog input 0:

Serial.println(analogRead(0));

delay(2000);

}

Es posible configurar:

• puerto

• velocidad de transmisión (baudios)

• cantidad de bits de datos

• paridad

• bits de stop

• formato de visualización: A (ASCII) H (Hexa) D (Decimal)

• separador entre caracteres y entre grupos de valores

• archivo de registro

• separador de campos para el archivo de registro

• si se agrega fecha y/o hora a cada línea del archivo de registro

• si se guarda en el archivo de registro todo lo que se recibe o solo cuando una línea es diferente a la anterior.

• destino web request: a qué URL se envían datos

• índice de inicio y fin de substring (trabaja sólo con una sección de la línea recibida)

18

3. Sistema de adquisición de datos

El sistema de ejemplo utiliza un sensor de temperatura y humedad DHT11 (muy económico) conectado a un

Arduino Uno, que se encarga de comunicarse con el sensor y envía los datos a la PC utilizando puerto serie.

En la PC se utiliza el programa dcterm descripto anteriormente, que recibe un string del Arduino, lo muestra

en pantalla, registra fecha y hora de cambios en las variables medidas, y envía los datos del sensor a un

servidor web, donde son recibidos por un script PHP que los guarda.

Una web utilizando AJAX llama a otro script PHP que recupera esos datos y de esta manera se presentan en

pantalla.

Es una forma muy simple y barata de implementar un sistema de adquisición de datos remotos.

captura de pantalla – el sistema de adquisición en firefox + dcterm enviando datos (servidor remoto)

19

fotografía – el sistema de adquisición en firefox + chrome (Android) + dcterm enviando datos (servidor remoto)

/*

Lee temperatura y humedad de un DHT11

Calcula la sensacion termica

Envia un sting con los resultados a una PC

*/

#include "DHT.h"

#define DHTPIN 2 // what digital pin we're connected to

#define DHTTYPE DHT11 // DHT 11

DHT dht(DHTPIN, DHTTYPE);

void setup() {

Serial.begin(57600);

dht.begin();

}

void loop() {

delay(5000);

20

// Lee humedad

float h = dht.readHumidity();

// Lee temperatura

float t = dht.readTemperature();

// Verifica si hubo errores en comunicación con sensor

if (isnan(h) || isnan(t) ) {

Serial.println("Failed to read from DHT sensor!");

return;

}

// Calcula sensacion termica

float hic = dht.computeHeatIndex(t, h, false);

// envía resultados

Serial.print(t);

Serial.print(" *C - ");

Serial.print(h);

Serial.print(" % - ");

Serial.print(hic);

Serial.print(" *C\n");

}

21

dcterm mostrando temperatura, humedad y sensación térmica

dcterm en Windows 7

Como dcterm se puede configurar para hacer un request:

destino_web_request = "http://localhost/clima/recibe.php"

Y en el código que recibe, registra, visualiza, etc:

if destino_web_request!= "":

datos = {'datos': linea}

requests.get(destino_web_request, params=datos)

donde datos es un diccionario con los datos a enviar, en este caso, la línea recibida.

Es como si hiciéramos http://localhost/clima/recibe.php?datos=linea

En el servidor tenemos un script PHP “recibe.php” que recibe estos datos y los guarda en un archivo de

texto “clima.txt”

22

http://localhost/clima/recibe.php

<?php

if (isset($_GET['datos'])) {

$par = $_GET['datos'];

$f = fopen("clima.txt", 'w');

fwrite($f, $par);

fclose($f);

}

?>

Un segundo script condulta.php es invocado por index.html que contiene las sentencias JavaScript que

inicializan y realizan los pedidos AJAX

<?php

if (isset($_GET['dato'])) {

$par = $_GET['dato'];

if ($par == 'temp') {

$line = '';

$f = fopen("clima.txt", 'r');

$line = fgets($f);

echo $line;

fclose($f);

}

}

?>

Su función es simplemente leer el contenido de “clima.txt” y devolverlo como string.

Dentro de index.html, cada 12s se ejecuta consulta,php y el resultado (en this.responseText) se muestra

dentro de un div:

if (this.responseText != null) {

document.getElementById('temp').innerHTML = this.responseText;

23

Bonus: serie-test (Qt / QtExtSerial)

Es un proyecto realizado en el IDE QtCreator, con Qt, QtExtSerial y C++ que ejemplifica las operaciones más

elementales del puerto serie: abrir, cerrar, enviar, recibir y verificar el estado.

test-serie – corriendo en GNU/Linux KDE y conectado a un Arduino (programa de los asteriscos)

Se incluye junto con un documento que explica paso a paso cómo incluir la librería QtExtSerial

j. Repositorio

Las carpetas en https://github.com/diegocode/serie tienen la siguiente estructura:

.

├── controldig aplicación controldig y dig_es (GUI)

│ ├── docs documentación / instrucciones de uso

│ └── hardware circuito de prueba

├── dcterm aplicación dcterm

│ ├── arduino programas para pruebas con Arduino

│ ├── clima aplicación web para el ejemplo de adquisición remoto

│ └── docs documentación / instrucciones de uso

├── referencia material teórico

│ ├── ejemplos ejemplos del material teórico + otros

│ └── Qt + Cpp instrucciones Qt + QtCreator y ejemplo serie-test

└── sloopback aplicación de diagnóstico

└── docs documentación / instrucciones de uso

24

Commits:

Commits on Feb 14, 2016

- reorganización y documentación mejorada


- documentación corregida + orden fuentes


- gui control_dig


- referencia y loopback ok + ejemplo Qt y Cpp


- terminal base + adquisición de datos y site ajax + inicio referencia

Commits on Jan 30, 2016

- log funcionando - con configuración

- con clase timer propia + ctrl-c correcto - Timer-daemon=True


- con clase timer propia + ctrl-c correcto

- scripts+config+docs

- scripts+config+docs


- docs folder

- control_dig nombres custom

- control digital funcional linea comandos


- primer esbozo de loopback

25

k. Discusión y conclusiones

La producción realizada resulta un buen punto de partida para continuar con el trabajo hacia el total

cumplimiento de los objetivos planteados y otras inquietudes que se fueron incorporando durante el

desarrollo.

Se produjo buen material de referencia y se desarrollaron ejemplos y aplicaciones que si bien necesitan de

desarrollo adicional resultan útiles y cumplen tareas que no están disponibles en otros programas tanto de

GNU/Linux como de Windows.

Como logro adicional, el material se probó con éxito en diversas versiones de Windows, por lo que

potencialmente es multiplataforma, lo que agrega valor,

“producir material de referencia y aprendizaje, ejemplos... “ como se ha planteado en (a) resulta además de

un objetivo, una motivación para continuar incorporando recursos.

Algunos temas importantes que quedan pendientes para incluir:

- Ejemplos y aplicaciones utilizando ANSI C (para GNU/Linux y Windows3, multiplataforma)

3. El autor ha desarrollado material sobre port serie bajo windows y está disponible en http://diegocodevilla.com.ar

26

- Circuitos y ejemplos de aplicación de los programas desarrollados.

En cuanto a las aplicaciones, quedan muchísimas mejoras. Entre otras:

• en dcterm:

- agregar una GUI con tkinter (hay un prototipo en el repositorio) – tkinter no requiere instalación y es liviana –

(pensando en Raspberry y similares)

- La GUI permitiría: colores para diferentes formatos de visualización, varias líneas para envío de mensajes,

configuración gráfica, cuadros de abrir archivo, etc..

- Configuración: incorporar configuración (la versión actual es hardcoded)

- Mejorar el manejo de errores.

- Incorporar Threads para independizar tx, rx y eventualmente soportar múltiples puertos.

- Incorporar soporte para TCP, UDP

- Incorporar generación de mecanismos de chequeo de integridad (CRC, LRC, etc)

• en controldig

- Mejorar el manejo de errores

- Corregir nombres descriptivos a patas

- Soporte de múltiples puertos.

- Completar GUI con cuadros de opciones y configuración.

- Generar scripts de estados en forma visual.

• Para todas: incorporar mecanismos de internacionalización (con gettext)

Los tiempos planificados se cumplieron en buena medida, teniendo en cuanta que se contaba con

conocimientos previos (básicos al menos) de las tecnologías utilizadas. Aun así, en el tiempo asignado al

proyecto, además de PySerial, se investigó sobre Threads en Python, se desarrolló una clase Timer muy

interesante para uso general; se estudió la librería request. Se aprendió a desarrollar GUI realativamente

complejas con wxWidgets (con wxGlade y “a mano”) y TkInter, y distribución de aplicaciones Python (en

windows y GNU/Linux) Los conocimientos sobre estos dos últimos temas no se pudieron plasmar sin

embargo, en el trabajo actual.

27

Bibliografía y referencias

Libros

Hughes, J.M, - 2011 - “Real World Instrumentation with Python” - USA – O'Reilly Media

Jackson, Cody – 2011 - Learning to Program Using Python – USA

S. Morris, Alan S. - 2001 - “Measurement and Instrumentation Principles” - UK - Butterworth-Heinemann

Mayné, Jordi – 2009 - “Sistemas de Comunicaciones” - España – Silica

Guerrero, Yuste, Martínez - “Comunicaciones Industriales” - España – Marcombo

Duque, Raúl González – “Python para todos” - España

Notas de aplicación y artículos técnicos

Varios - March 2000 (rev 2004) - “Comparing Bus Solutions” (SLLA067A) – USA – Texas Instruments

N/A – N/A - “Fundamentals of RS–232 Serial Communications – App. Note 83” - USA – Dallas Semiconductor

N/A – 2003 - “Is RS-232 robust enough for use in industrial systems? (It can be !)” - Robust DataComm

N/A – 2000 - “Selecting and Using RS-232, RS-422, and RS-485 Serial Data Standards” - USA – Maxim Integrated

N/A – 2002 - “Interface Circuits for TIA/EIAĆ232ĆF” (SLLA037A) – USA – Texas Instruments

Recursos web

PySerial: http://pyserial.readthedocs.org/en/latest/index.html

Peacock, Craig – 1998 - Interfacing the Serial / RS232 Port V5.0 - http://wiki.beyondlogic.org

TkInter: http://tkinter.unpythonic.net/wiki/FrontPage

Python documentation: https://docs.python.org/2/

Request: http://docs.python-requests.org/en/master/

28

Recursos para la utilización del puerto serie en entornos ... · Abstract El siguiente trabajo es...

Documents

Transcript of Recursos para la utilización del puerto serie en entornos ... · Abstract El siguiente trabajo es...