Los lenguajes de programación son una vital herramienta a la hora de crear nuevos proyectos de hardware porque, ¿qué proyecto no tiene interacción con el software?. La nueva generación de ingenieros tiene en su poder una diversidad de herramientas para posicionar su proyecto en la cumbre. No es desconocido que Python se ha vuelto uno de esos lenguajes de prototipado rápido en el mundo de los sistemas embebidos y es que con las nuevas plataformas de ordenadores con procesadores ARM, podemos comenzar a crear cosas que hace veinte años en el campo de la ingeniería electrónica tradicional no se podía lograr. En este tutorial, les enseñaré cómo utilizar Python en conjunto con Arduino y la comunicación serial. Con este artículo pretendo que nuestros lectores puedan establecer comunicación básica entre este lenguaje de programación y arduino haciendo uso de la librería pyserial. Así que, sin más te invito a que des un vistazo.
Python es un lenguaje de programación orientado a objetos, interpretado, indentado, multitipado, y de fácil entendimiento. Al ser un lenguaje orientado a objetos, nos brinda la oportunidad de generar un código bastante cercano a cómo se describirían las cosas en la vida real. Esto se hace a través de un modelo conocido como clase, y dentro de esta clase se define lo que se conoce como atributos y métodos que al crear un objeto definirán las características única de ese mismo objeto.
Es un lenguaje interpretado, quiere decir que no tiene que compilar el código en su totalidad. Esto permite que Python sea un lenguaje de programación multiplaforma al poder ejecutarse en cualquier sistema operativo independientemente del hardware que éste utilice.
Al ser indentado permite leer el código fácilmente. Una vez escuché hablar que en base a estudios realizados, se dice que el ser humano entiende de manera más rápida un código gracoas a la indentación. La indentación es una buena práctica que todo programador debería aplicar, sin embargo en python esto es obligatorio lo cual te ayudara a ser más organizado.
Es un multipado porque python va asignando el tipo de variables y además, éstas pueden cambiar su tipo a lo largo del programa. Finalmente pero no menos importante, es de fácil entendimiento porque su sintaxis es bien parecida a un idioma lenguístico lo cual facilita el aprendizaje de las funciones y así aprovechar todo su potencial.
Materiales o herramientas
En este tutorial lo que voy a hacer es a crear una comunicación serial entre python y arduino a través de la librería pyserial. Utilizaré diferentes ejemplos donde observarás cómo se puede utilizar python para crear un protitapado rápido de proyectos en electrónica. Lo que vas a necesitar es lo siguiente:
- Fedora 20 o cualquier distribución Linux/GNU
- Python 2.7.5
- Arduino UNO
- Librería pyserial
- Librería time
Adicional, estoy utilizando Linux/GNU Fedora de 64 bits. Para aquellos que tengan esta distribución pueden bajar pyserial a través de:
|
1 |
su -c 'yum install pyserial' |
No hay necesidad de instalar la librería time ya que ésta forma parte de las líbreas que vienen por defecto al instalar python.
Encontrando puerto serial donde se encuentra el arduino
Para encontrar dónde está ubicado tu arduino, puedes hacer un primer chequeo. En este caso verificar que hay algún puerto serial disponible teniendo una ruta patrón tipo /dev/ttyUSB o /dev/ttyAMC. Esto lo puedes hacer desde consola con el comando ls.
|
1 2 |
ls /dev/ttyUSB* ls /dev/ttyACM* |
Luego para hacer una última verificación puedes utilizar el comando:
|
1 |
dmesg | tail -3 |
En mi caso, el arduino aparece conectado en el puerto ttyACM1. Entonces, ese es el puerto que voy a utilizar para este tutorial.
Leyendo datos desde Python a partir de Arduino
Veamos el código a utilizar en Arduino:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
void setup() { // Se establece la conexión serial Serial.begin(9600); } void loop(){ if (Serial.available() > 0) { if (Serial.read() == 107) { // Se envia el caracter 445.45 Serial.println(445.45); } } } |
Ahora veamos el código a utilizar en python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#!/usr/bin/python # -*- coding: iso-8859-1 -*- import time import serial # Iniciando conexión serial arduinoPort = serial.Serial('/dev/ttyACM1', 9600, timeout=1) flagCharacter = 'k' # Retardo para establecer la conexión serial time.sleep(1.8) arduinoPort.write(flagCharacter) getSerialValue = arduinoPort.readline() #getSerialValue = arduinoPort.read() #getSerialValue = arduinoPort.read(6) print '\nValor retornado de Arduino: %s' % (getSerialValue) # Cerrando puerto serial arduinoPort.close() |
Explicaré qué es lo que hace cada código correspondiente. El código de Arduino es simplemente un pequeño programa que se encarga de enviar el string 445.45 de manera serial únicamente cuando éste reciba el caracter k, que en decimal seria 107.
Ahora, en el código python este se vuelve interesante. Primeramente he importado dos librerías que van a hacer de utilidad, la librería pyserial ya que con ella enviaremos información serial a arduino y la librería time para crear retardos en el código.
Se crea un objeto arduinoPort a partir de la clase Serial en donde le indicamos el puerto por donde está conectado el Arduino así como la velocidad de transmisión en baudios, y el timeout. Para aquellos que no saben qué es el timeout, este es el tiempo máximo que esperará el programa para establecer la comunicación serial con el dispositivo. Luego, se crea una variable llamada flagCharacter que contiene caracter que disparará el código que imprimirá el resultado de lo que enviará el Arduino.
Adicionalmente se agrega un retardo a través del método sleep de la librería time de 1.8 s y luego a través del método write enviamos a arduino el caracter. Cuando el caracter llega al Arduino éste devolverá un parámetro que será recibido por la variable getSerialValue para así mostrarlo en consola. Finalmente ,para cerrar el puerto serie se llama el método close.
Y esto es el resultado:
|
1 |
Valor retornado de Arduino: 445.45 |
Ahora veamos qué pasa si en vez de utilizar el método readline utilizamos el read.
El código python a utilizar es:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#!/usr/bin/python # -*- coding: iso-8859-1 -*- import time import serial # Iniciando conexión serial arduinoPort = serial.Serial('/dev/ttyACM1', 9600, timeout=1) flagCharacter = 'k' # Retardo para establecer la conexión serial time.sleep(1.8) arduinoPort.write(flagCharacter) #getSerialValue = arduinoPort.readline() getSerialValue = arduinoPort.read() #getSerialValue = arduinoPort.read(6) print '\nValor retornado de Arduino: %s' % (getSerialValue) # Cerrando puerto serial arduinoPort.close() |
La impresión en consola es:
|
1 |
Valor retornado de Arduino: 4 |
Y para sumarle algo más, observa qué pasas cuando utilizas el método read(N).
El código en python es:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
#!/usr/bin/python # -*- coding: iso-8859-1 -*- import time import serial # Iniciando conexión serial arduinoPort = serial.Serial('/dev/ttyACM1', 9600, timeout=1) flagCharacter = 'k' # Retardo para establecer la conexión serial time.sleep(1.8) arduinoPort.write(flagCharacter) #getSerialValue = arduinoPort.readline() #getSerialValue = arduinoPort.read() getSerialValue = arduinoPort.read(6) print '\nValor retornado de Arduino: %s' % (getSerialValue) # Cerrando puerto serial arduinoPort.close() |
La impresión en consola es:
|
1 |
Valor retornado de Arduino: 445.45 |
A partir de estos resultados se pueden olfatear que el método readline se encarga de imprimir toda la información que envia el arduino hasta que éste termina con un salto de línea “\n”. Mientras que para el método read sin argumentos, éste sólo devuelve el resultado de un caracter o bien un byte y para cuando se utiliza el método read(N) éste imprimirá N bytes. Como 5.4544 contiene 6 bytes, entonces es de esperar que read(6) imprimirá el valor completo que envió Arduino.
Indagaré ahora sobre algunas aspectos que pueden serte de utilidad a la hora de comenzar a trabajar con arduino y python. Crearé un archivo en python que sea capaz de imprimirme el puerto donde se encuentra conectado el arduino, además de verificar si el puerto seria está abierto, así como un dump de la configuración que mostrará datos la velocidad de transmisión, tipo de paridad, tamaño del bit y tal.
También para evitar lectura de datos erronéos cada vez que el arduino abre el puerto serial, utilizaré los métodos flushInput((), y setDTR(). El primero se encargará de limpiar el buffer de cualquier residuo de información que haya quedado de pruebas anteriores y el segundo lo utilizaré dos veces para hacer un flaco de negativo a positivo, esto lo que hará es reiniciar el Arduino colocando en estado bajo y luego alto el pin DTR.
El código en python que genera todo lo mencionado anteriormente es:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
#!/usr/bin/python # -*- coding: iso-8859-1 -*- import sys, time, serial serialPort ='/dev/ttyACM1' def infoSerial(): print '\nDatos generales de la comunicación serial establecida' # Iniciando conexión serial arduinoPort = serial.Serial(serialPort, 9600, timeout=1) # Reset manual del Arduino arduinoPort.setDTR(False) time.sleep(0.3) # Se borra cualquier data que haya quedado en el buffer arduinoPort.flushInput() arduinoPort.setDTR() time.sleep(0.3) print '\nEstado del puerto: %s ' % (arduinoPort.isOpen()) print 'Nombre del dispositivo conectado: %s ' % (arduinoPort.name) print 'Dump de la configuración:\n %s ' % (arduinoPort) print '\n###############################################\n' # Cerrando la conexión serial arduinoPort.close() if __name__ == '__main__': infoSerial() |
Al ejecutar el código en python, esto es lo que imprimirá:
|
1 2 3 4 5 6 7 8 9 10 11 |
Datos generales de la comunicación serial establecida Estado del puerto: True Nombre del dispositivo conectado: /dev/ttyACM1 Dump de la configuración: Serial<id=0x7f7519041290, open=True>(port='/dev/ttyACM1', baudrate=9600, bytesize=8, parity='N', stopbits=1, timeout=1, xonxoff=False, rtscts=False, dsrdtr=False) ############################################### |
Bueno, espero que les haya gustado esta primera entrada acerca de Python y Arduino y te invitamos a que nos sigas visitando. Hasta la próxima.
Para más información acerca de otros métodos que te pueden resultar interesantes a la hora de trabajar con pyserial, visitar su enlace de documentación oficial.
http://pyserial.sourceforge.net/pyserial_api.html
Inspirado en:
