¡Descarga Informacion De Arduino y Python y más Guías, Proyectos, Investigaciones en PDF de Programación Avanzada de Informática solo en Docsity!
Python + Arduino –
Comunicación Serial
enero 5, 2015 Kiara Navarro Arduino, Arduino, Arduino para principiantes, Comunicación
serial, Linux/GNU, Planet Fedora, Programación, Python
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: o Fedora 20 o cualquier distribución Linux/GNU o Python 2.7. o Arduino UNO o Librería pyserial o Librería time
Puerto donde está conectado el Arduino. Verificación a través de consola. 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. Serial.println(445.45); } } } Ahora veamos el código a utilizar en python 1 2 3 4 5 #!/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 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. 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 #!/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()
o http://www.embarcados.com.br/python-arduino-comunicacao-serial/ Segunda información de arduino y python Python y Arduino - Comunicación en serie
por Cleiton Bueno en Miércoles, 06 de agosto 2014.
Antes de trabajar con Python y Arduino para la comunicación serial, es importante entender este idioma.Python es un lenguaje dinámico y robusto que fue creado por Guido van Rossum (1991) y escrito en C (CPython). Se interpreta y multiplataforma. ¡Sí! "Rueda" en Linux, Windows Mobile, Web, incrustado, VxWorks y desde otras plataformas. Es fácil de aprender, potente y productivo de muchas maneras. Vamos a nombrar unos pocos: su sintaxis;tipificación fuerte; funciones y bloques de código delimitados por sangrado; es un lenguaje dinámico; y ofrece estructuras de datos de alto nivel (tuplas, listas y diccionarios). Usted necesita algo rápido para la creación de prototipos y validación? Ir Python! Con unas pocas líneas y módulos de gran alcance se pueden implementar fácilmente aplicaciones que hacen uso de cliente-servidor TCP / UDP, FTP, XML, REST, PDI, hilos, GUI, Signal, IPC, base de datos y la comunicación con los protocolos industriales, tales como Modbus, RS485 y RS232. También es posible desarrollar aplicaciones Web.
Y en el mundo integrado, interpretado Python es lento! ¿En serio? Python no es interpretado (novedad viene alrededor, espera), puede tener acceso a la interfaz GPIO / sys / class / GPIO, la manipulación de una manera muy simple y elegante su hardware. Ahora que sabemos un poco de la gama de opciones que marco a partir de una comunicación serie. Vamos a ver lo que necesitamos y en unas pocas líneas nos comunicamos a través de serie entre Python y Arduino. Anfitrión configuración del entorno Para este artículo vamos a utilizar la distribución Ubuntu 4.13 (Raring Ringtail) de 64 bits y siguiendo sus requisitos previos se enumeran: Python instalado (estoy usando la versión 2.7.2); La biblioteca python-serie (PySerial); Arduino UNO; Firmware para la comunicación serial escrito al Arduino. En la siguiente sección del puesto mostrar su boceto. Confirmación de la versión de Python y PySerial: 1 2 3 4 cleiton@linuxVM:~/projetos/python/communicationSerial$ python --version Python 2.7.2+ cleiton@linuxVM:~/projetos/python/communicationSerial$ pip freeze | grep serial pyserial==2. Si por alguna razón la pitón no --version muestra la versión y / o pip no existe en la máquina, podemos instalarlos con los siguientes pasos:
serial.begin( 9600 ); } void loop(){ if (Serial.available() > 0 ){ if (Serial.read() == 116 ){ // letra t // Lento o pino A0, aqui estamos obtendo o valor valAnalog = analogRead(PinAnalogLM35); temp = (valAnalog * 500 ) / 1023 ; Serial.println(temp); } } } El ejemplo del firmware volverá la temperatura al enviar el carácter 't' a través del puerto serie. Para obtener más información, véase un artículo acerca de la comunicación en serie en la Arduino. Programas de ejemplo con Python y Arduino para comunicaciones en serie Veamos un ejemplo básico para trabajar con el módulo PySerial: 1 2 3 4 #!/usr/bin/python
- *- coding: iso- 8859 - 1 - *-
import serial
ser = serial.Serial('/dev/ttyUSB0', 9600 ) ser.write('5') #ser.write(b'5') #Prefixo b necessario se estiver utilizando Python 3.X ser.read() Vamos a entender cómo el código de seguridad. En primer lugar, en la línea 4, antes que nada, se importa el módulo de serie. A continuación, debe iniciar la conexión al puerto serie con la llamada al método serial.Serial (PORTA_SERIAL, BAUD_RATE). Ya que estamos usando Linux y Arduino es una clase CDC USB de serie de hardware, dispositivo serie creada es / dev / ttyUSB0. Este proceso no ha sido probado en Windows, pero me parece que eso es sólo el número sin el COM. Después de hacer este ajuste y la velocidad de transmisión configurado correctamente, que en mi caso es de 9600 bps, el carácter siguiente línea 7 se envía '5' para el dispositivo a través del puerto serie. Si todo va bien y todo dispositivo está programado para responder de la línea 9 se realiza para leer los datos que llegan en el puerto serie del ordenador. Fácil ¿no? Python es demasiado! Ahora, utilizando el ejemplo de firmware, vamos a escribir una aplicación para comunicarse con él. Código (exemplo01.py): 1 2 3 4 5 6 7 8 9 #!/usr/bin/python
- *- coding: iso- 8859 - 1 - *-
import time import serial
Iniciando conexao serial
comport = serial.Serial('/dev/ttyUSB0', 9600 ) #comport = serial.Serial('/dev/ttyUSB0', 9600, timeout=1) # Setando timeout 1s para a conexao
Se crearon dos variables, una con el carácter 't' en la línea 11 y otro en la línea 12 con el mismo contenido, sólo con el valor en ASCII. En la línea 15 implementamos algo que no se encuentra en la documentación, pero como yo había pasado por esto antes, me pareció digno de mención. Se requiere que el tiempo para la conexión, la creación de un retraso para la escritura de datos. En el caso de este ejemplo, los valores entre 1,5 a 1,8 s causado una puntuación perfecta, pero jamás tuvo en caso de un retraso de 0,2 o 0,5 causa el mismo resultado. En la línea 17 o 18 escrito en serie utilizando la codificación ASCII o el carácter.Inmediatamente después de los datos del puerto serie se lee a través del método comport.readline () en la línea 20, que recibe el valor de lectura y la almacena en VALUE_SERIAL cantidad variable aparece entonces en la pantalla a través de la función de impresión. Todo esto ocurre sin grandes emociones, que terminó indicando el final de la relación con comport.close () en la línea 25. Uno más detalles sobre la conexión establecida en la línea 8. Las acciones con el puerto serie puede ser manipulado por la variable de puerto com, que recibe este sentido y podemos decir que es el descriptor de archivo para el momento en que cerramos la comunicación. Ahora bien, si nos fijamos en el ejemplo básico que creamos y nuestro programa, la parte que se ocupa de la recepción es diferente. En el primer ejemplo se método ser.read () utiliza y luego comport.readline (). ¿Es la misma cosa? ¡No! Vamos a ver qué cambios utilizando el método comport.read () en exemplo01.py. 1 2 3 4 5 6 7 8 9 #!/usr/bin/python
- *- coding: iso- 8859 - 1 - *-
import time import serial
Iniciando conexao serial
comport = serial.Serial('/dev/ttyUSB0', 9600 ) #comport = serial.Serial('/dev/ttyUSB0', 9600, timeout=1) # Setando timeout 1s para a conexao
PARAM_CARACTER='t' PARAM_ASCII=str(chr( 116 )) # Equivalente 116 = t
Time entre a conexao serial e o tempo para escrever (enviar algo)
time.sleep(1.8) # Entre 1.5s a 2s #comport.write(PARAM_CARACTER) comport.write(PARAM_ASCII) #VALUE_SERIAL=comport.readline() VALUE_SERIAL=comport.read() #VALUE_SERIAL=comport.read(3) print '\nRetorno da serial: %s' % (VALUE_SERIAL)
Fechando conexao serial
comport.close() Salida: 1 2 3 cleiton@linuxVM:~/projetos/python/communicationSerial$ sudo python ./exemplo01.py Retorno da serial: 2 cleiton@linuxVM:~/projetos/python/communicationSerial$ Ahora, utilizando el tercer modo, comport.read (3):
Fechando conexao serial
comport.close() Salida: 1 2 3 cleiton@linuxVM:~/projetos/python/communicationSerial$ sudo python ./exemplo01.py Retorno da serial: 26. cleiton@linuxVM:~/projetos/python/communicationSerial$ Usted podría notar la diferencia? Vamos a enumerar lo que sucede cada usando uno de los métodos utilizados. comport.readline (): Hace que la lectura de los datos del puerto serie hasta que el carácter '\ n' es recibido, o una línea completa se lee; comport.read (): Realiza la lectura de puerto serie a sólo 1 byte; comport.read (N): se leen de un número limitado de bytes, informado por el parámetro N del método. En nuestro caso "27.37" contiene 5 caracteres, por lo que 5 bytes. Vamos a tomar la prueba. 1 2 3 4 #!/usr/bin/python
- *- coding: iso- 8859 - 1 - *-
import time
import serial
Iniciando conexao serial
comport = serial.Serial('/dev/ttyUSB0', 9600 ) #comport = serial.Serial('/dev/ttyUSB0', 9600, timeout=1) # Setando timeout 1s para a conexao PARAM_CARACTER='t' PARAM_ASCII=str(chr( 116 )) # Equivalente 116 = t
Time entre a conexao serial e o tempo para escrever (enviar algo)
time.sleep(1.8) # Entre 1.5s a 2s #comport.write(PARAM_CARACTER) comport.write(PARAM_ASCII) #VALUE_SERIAL=comport.readline() #VALUE_SERIAL=comport.read() VALUE_SERIAL=comport.read( 5 ) print '\nRetorno da serial: %s' % (VALUE_SERIAL)
Fechando conexao serial
comport.close() Salida:
