Conexión arduino-python

Informe de proyecto integrador

Presentado por:

Jose Miguel Sánchez Galviz

Steven Haney Alvarez Bueno

Curso de algoritmia y programación T-01

Presentado a:

Ing. Diego Andres Robles Nieto

Universidad Simón Bolívar

Junio de 2021
 1. INTRODUCCIÓN.

Con el presente trabajo se realiza un detallado informe del proyecto integrador del tercer
semestre de ingeniería mecatrónica de la universidad Simón Bolívar. En este informe los
estudiantes pretendemos demostrar los conocimientos adquiridos durante el desarrollo del
presente semestre académico en la asignatura de algoritmia y programación, creando una
conexión entre una placa de Arduino y un código de Python funcional, de manera que esta
pueda ser usada para resolver diferentes tipos de problemas relacionados con la medición de
temperatura, humedad y distancia.

Para el desarrollo del problema planteado, se utilizan distintos sensores de Arduino, un sensor
ultrasónico y un sensor de temperatura y humedad los cuales están controlados por un
pulsador también conectado al Arduino. En Python se leerán los datos arrojados por el
Arduino y se podrá guardar los datos y comparar los diferentes datos guardados.

Con este proyecto se espera aprender acerca de la programación en diferentes tipos de

programas y cómo enviar datos de un programa a otro, incluso cuando usan diferentes tipos
de lenguaje de programación, ya que esta experiencia nos puede ayudar en el ámbito laboral
para la creación de nuevos programas que cumplan estas funciones.

Presentación del proyecto en video:

https://youtu.be/HReyzz_8qF8

2. OBJETIVOS.

El objetivo principal de este proyecto es aprender acerca del funcionamiento y uso de un

Arduino conectado con el software Python para resolver distintas clases de problemas que
involucren el uso de ambos programas. También se busca utilizar diferentes tipos de sensores
para entender las diferencias en la programación de cada uno de ellos y cómo hacer que los
datos sean correctamente enviados al programa python, cuando hay varios datos siendo
enviados al mismo tiempo.

3. MATERIALES DEl HARDWARE

Para la elaboración del proyecto es indispensable la construcción de un hardware que realice

la toma de datos, que luego serán procesados por medio del programa python creado. A
continuación se presentan los materiales usados en el proyecto integrador junto con la
función que cumplen cada uno de ellos.

Arduino UNO La placa de Arduino

usada sería el Arduino
uno, por su fácil uso y
capacidad de conectar
varios sensores al mismo
tiempo

Sensor HC-SR04 Un sensor ultrasónico que

mide la distancia desde su
lugar en el espacio hasta
el obstáculo más cercano
al que esté apuntando,
con un límite de 400 cm.

Sensor DHT-22 Un sensor de humedad y

temperatura el cual tiene
limites de -40 grados
Celsius a 50 grados
Celsius y límites de 0 a
100 en porcentaje de
humedad.

Pulsador Un pulsador usado en el

Arduino para controlar las
lecturas de los datos
tomados por los sensores.
 4. CONEXIÓN.

La conexión en un sistema de arduino es una de las partes más importantes, ya que es la que
permite que la información se mueva de un lugar a otro en orden y de manera controlada. En
las siguientes imágenes se mostrarán las diferentes conexiones que tiene nuestro sistema de
arduino, con cada uno de los sensores usados y cables que diferencian el lugar de cada
conexión

Representación de Conexiones

Conexiones físicas

En la primera imagen se muestra una representación virtual de nuestro sistema. En el sistema

real se usa la función pull_up para reemplazar la resistencia en los pines 8, 9 y 13, también se
usa la función pinmode para configurar los pines 8 y 10 como pin a tierra y 5 voltios, ya que
esos pines son limitados en el arduino, el “trigger” del sensor ultrasónico está conectado al
pin 2 y el “echo” del mismo sensor esta conectado al pin 3, el pin de información del sensor
dht seria el pin 9, además en físico se conectó simultáneamente una resistencia de 330Ω
(ohmios), el pulsador estaría conectado al pin 13 y al pin tierra que se encuentra al lado de
este, para todas las conexiones se usaron los cables típicos macho/hembra de Arduino para
cada uno de los pines del sensor ultrasonidos.
 5. FUNCIONES.

La idea de este sistema se puede implementar en muchos ámbitos laborales y educativos.

Gracias a las herramientas del proyecto que se pueden implementar fácilmente, se pueden
usar en cualquier campo que sea necesario usar medir temperatura o distancia. Como por
ejemplo, en casos donde sea necesario medir la exposición térmica por factores de riesgo, en
estudios o investigaciones que convienen estos factores; en cualquier campo donde sea
necesario medir los factores de temperatura, humedad o distancia, como con un contador de
objetos que se necesiten mantener a una temperatura estable.

6. CÓDIGO.

Código de arduino:

fragmento 1

#define PIN_TRIG 2
#define PIN_ECHO 3
#include "TinyDHT.h"
#define DHTPIN 9
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
int boton = 13;

Todo inicia desde aquí, primero será es necesario definir algunos pines e incluir la librería
“TinyDHT.h” ( se probaron todas las demás librerías de sensores DHT pero esta fue la única
que funcionó en nuestro caso )

fragmento 2 del código de arduino

float getDistance(int p_trig, int p_echo){

float _val;
digitalWrite(p_trig, LOW);
delayMicroseconds(4);
digitalWrite(p_trig, HIGH);
delayMicroseconds(10);
digitalWrite(p_trig, LOW);
_val = pulseIn(p_echo, HIGH);
 _val = _val/58.3;
if(_val >= 2 and _val <= 400)
return _val;
return -1;

Se usa getdistance para pedir los valores de las variables del trigger y el echo, inicia con el
pin trigger (2) esperando en baj (0) por unos 4 mil sec, luego si manda voltaje en alto al pin,
y luego se le dice que vuelva a bajar a 0 la corriente del pin.

A continuación se hace una lectura del pulso que está recibiendo el pin del echo (3) usando
la función pulseIn que se guarda como “ _val ” luego esta se divide entre 58,3 para tenerla la
distancia, para llegar a esto pero se hace el siguiente cálculo:

Ya el sensor ultrasónico no arroja distancia directamente, sino el tiempo en milisegundos que

demora en ir y volver a la onda de sonido hasta el punto que toque. Sabiendo que la velocidad
del sonido es 343 m/s esta es necesaria pasarla a centímetros/milisegundos así:

343 m/ s∗100 cm/m∗((1/100.000 .000)∗s/ µs)=(1/29.,5∗cm/µs)

esto nos daría la distancia total, pero como el sonido va y vuelve, hace el recorrido dos veces,
así que es necesario dividir entre dos la distancia dada, o multiplicar por 2 el divisor:

Distancia( cm)=Tiempo (µs )/29,15∗2=Tiempo(µs)/58.3

Así que por lo tanto en el código del Arduino se dividirá el valor arrojado del sensor entre
58,3

fragmento 3 del código de arduino

Serial.begin(9600);
pinMode(boton,INPUT_PULLUP);

delay(50);

pinMode(PIN_TRIG, OUTPUT);
pinMode(PIN_ECHO, INPUT);

pinMode(8, OUTPUT);
pinMode(10, OUTPUT);

digitalWrite(8,LOW);
digitalWrite(10,HIGH);
 dht.begin();
delay(50);
float distancia;

Aquí en el void setup, iniciamos el uso de los pines del ultrasonidos y se define el uso del
pinmode del pulsador con pull up. Además se define la variable distancia.

fragmento 4 del código de arduino

if(digitalRead(boton)==0){

distancia = getDistance(PIN_TRIG,PIN_ECHO);

float TemC = dht.readTemperature();

float TemF = dht.readTemperature(true);

float Humd = dht.readHumidity();

Serial.println(distancia);

Serial.println(TemC);

Serial.println(TemF);

Serial.println(Humd);

delay(1000);

En este fragmento se mantendrá vacío el monitor hasta que se presione el pulsador, una vez
esto hará la lectura usando la función dht.read la cual arroja directamente la temperatura en
celsius, y arroja la temperatura en fahrenheit al añadir: (true). y se usa dht.read humidity para
leer el porcentaje de humedad en el aire. Para el ultrasonido solo lee lo anterior hecho en
“getdistance” y lo guarda en “distancia” Al final hay un delay de un 1 segundo para no
sobrecargar el arduino innecesariamente con loops ya que la lectura es manual.

Código de Python:
En el código de python aparecerá un menú en donde el usuario podrá seleccionar cual
función del código utilizar, y presionando el pulsador para pedir los datos de los sensores, en
el menú se podrán elegir las opciones de comparar, guardar, volver a tomar datos y salir, y el
usuario tendrá un total de 8 listas para guardar los datos y comparar los datos de las diferentes
listas. Se presentarán por fragmentos escritos para evitar aumentar mucho el tamaño del
archivo innecesariamente

fragmento 1 del código de Python ( inicio y base de datos ):

import serial
import time
conexion= serial.Serial("COM6",9600)
print("---------- Bienvenido al sistema de sensores ---------- \n")
aux=0
rt=[0,0,0,0]
rt1=[0,0,0,0]
rt2=[0,0,0,0]
rt3=[0,0,0,0]
rt4=[0,0,0,0]
rt5=[0,0,0,0]
rt6=[0,0,0,0]
rt7=[0,0,0,0]
rt8=[0,0,0,0]
nrevision=0

Se inicia la programación importando la librerías serial, se declara la conexión en el puerto

COM6 usando la velocidad normal del arduino de 9600, da un mensaje de saludo, se crea un
auxiliar para el bucle principal que al inicio siempre estará activo por que es: while(aux==0),
abajo del auxiliar se tiene la creación de una base de datos que usaremos para las lecturas de
las medidas y por último se crea una variable para dar el número de revisiones de lecturas
que ha realizado el usuario. (La variable rt se crea para evitar error al guardar sin tener una
lectura hecha)

fragmento 2 del código de Python( menú principal ):

while(aux==0):
aux3=float(input(.......)
if(aux3==0):
elif(aux3==1):
elif(aux3==2):
elif(aux3==3):
elif(aux3==4):
else:
print("Usted ha seleccionado una opción incorrecta")

Este fragmento contiene el menú principal del programa, el cual se accede desde el input en
el auxiliar 3, este tiene las opciones, leer sensores, guardar lecturas, comparar lecturas,
mostrar todas las lecturas, y cerrar programa.

fragmento 3 del código de Python (Lectura de sensores):

 if(aux3==0):
aux5=+1
nrevision=nrevision+aux5
rt=[]
print("\n---------- revision #",nrevision,"--------- \n
(Recuerde presionar el boton en el arduino para hacer la lectura)")
for i in range(4):
valores=conexion.readline().decode('ascii')
rt.append(float(valores))

En este fragmento muestra la función de lectura de sensores al elegir la opción en aux3, ,se
considera esta la función principal del proyecto, Inicia creando dos variables(aux 5 y
nrevision) que se usarán para el contador de revisiones. luego se vacía la variable rt (para
evitar errores al añadir los nuevos valores al usar append), imprime el número de revisiones,
y recuerda al usar hacer la lectura manual con el pulsador, una vez entra al bucle for se repite
4 veces por qué es el número de medidas, bucle en el cual hace una lectura del puerto COM6
y lo decodifica usando “ascii” que da valores numéricos y los guarda en “valores”, luego
estos valores son añadidos usando append la variable rt.

fragmento 4 del código de Python ( Guardar lecturas parte 1):

elif(aux3==1):
print(" \n Las variables guardadas son las siguientes:")
print(" | lectura 1:", rt1[0],"cm", rt1[1],"°C", rt1[2],"°F", rt1[3],"%")

En esta parte se muestra el inicio del guardado, al cual se ingresa seleccionando 1 en el menú
principal, luego imprime las variables valor por valor con su unidad al lado lo cual se repite
las 8 veces de cada lectura (está con rojo).
Dentro de una lectura si todos están en 0 es porque no se ha guardado nada antes, esto es
porque al inicio se declararon todas con 0 en sus cuatro espacios para que no diera error al
imprimir los vacíos.

fragmento 5 del código de Python ( Guardar lecturas parte 2):

v=0
while(v==0): #bucle de seguridad
n=int(input(" Diga donde desea guardar la lectura: "))
if(n==1):
rt1=rt
print(" | lectura 1:", rt1[0],"cm", rt1[1],"°C", rt1[2],"°F", rt1[3],"% |")
v=1
….
 else:
print("Seleccionó opción incorrecta, vuelva dar otro valor")

En el fragmento 5 se crea la variable “v” para activar el bucle automáticamente, pide donde
guardar la lectura y lo guarda en n, esto definirá qué variable usar, por ejemplo aquí es n=1
por ello entra al if correspondiente, toma la variable rt ,que se vacía en cada lectura, y la
guarda dentro de la lectura seleccionada, luego la imprime para comprobación del usuario y
luego cierra el bucle de guardado usando V=1.
Esto se repite (esta con rojo) con cada elif de las otras opciones en sus espacios
correspondientes, del 1 al 8, en caso de no estar dentro del rango envia error y vuelve a
preguntar dónde desea guardar, ya que no añadí algún cambio en v.

fragmento 6 del código de Python ( Comparador de lecturas parte 1 ):

elif(aux3==2):
print(" ¿Que variables desea comparar?")
print(" | lectura 1:", rt1[0],"cm", rt1[1],"°C", rt1[2],"°F", rt1[3],"%")

Como en el fragmento 4 esto es para que el usuario pueda ver todas las lecturas sin tener que
volver al menú principal, se repite con las 8 lecturas.

fragmento 6 del código de Python ( Comparador de lecturas parte 2 ):

aux7=0
while(aux7==0):
aux6=float(input(" Selecione la 1era lectura a comparar: "))
if(aux6==1):
comp=rt1
….
else:
print("Opcion incorrecta")
aux6=float(input(" Selecione su 2da lectura a comparar: "))
if(aux6==1):
comp1=rt1
…….
else:
print("Opcion incorrecta")
aux7=int(input("-----Presione (1) para cerrar, (0) hacer otra comparacion: "))

Esta herramienta que vuelve práctica esta programación, este fragmento muestra la parte
lógica del comparador, se crea un bucle while, pide al usuario que diga que lecturas variar, y
se copian las lecturas seleccionadas en otras variables (comp y comp1) para así ahorrar
espacio al comparar las medidas en la siguiente parte. en caso de que la persona se equivoque
vuelve a pedirle la variable que en que se equivocó.
además vuelve a pedir la variable aux7 por si el usuario desea hacer más comparaciones

fragmento 6 del código de Python ( Comparador de lecturas parte 3 ):

print("----- Comparaciones -----")

if( comp[0] == comp1[0]):
 print(" La distancia no varió")
else:
distancia_final=abs(comp[0]-comp1[0])
print(" La distancia varió: ",distancia_final,"cm")
…. aux7=int(input("-----Presione (1) para cerrar, (0) hacer otra comparacion: "))

Esta parte permite hacer las comparaciones, en este caso solo tomamos una medida ya que se
repite el la misma estructura para las 4. Como se había dicho antes se compara com y comp1,
se hace una resta y se dá el valor absoluto del resultado. luego la imprime.

fragmento 7 del código de Python ( mostrar todas las lecturas ):

elif(aux3==3):
print(" Todas las variables guardadas:")
print(" | lectura 1:", rt1[0],"cm", rt1[1],"°C", rt1[2],"°F", rt1[3],"% ")
print(" | lectura 2:", rt2[0],"cm", rt2[1],"°C", rt2[2],"°F", rt2[3],"%")
………...
Este fragmento solo hace la muestra de todas las lecturas, se repite la misma estructura pero
cambian solo los números de la lectura, es sencillo pero es muy útil para saber qué variables
guardar, o comparar o para ver todo sin cargar ninguna función. Como todas las funciones
principales, se accede desde el aux3 que es la selección del menú principal, imprime cada
valor y su unidad al lado derecho.

fragmento 7 del código de Python ( mostrar todas las lecturas ):

elif(aux3==4):
aux=1
print("\n \n--------------- Hasta luego!, espero le haya sido de ayuda ---------------")
else:
print("Usted ha seleccionado una opción incorrecta")

Este último fragmento tiene dos funciones simples pero útiles; Si la persona selecciona 4 en
el menú principal entra a este apartado donde se cierra el bucle while con aux=1 luego se
imprime una despedida. Por otro lado aquí se evita que la persona deba correr el programa
desde 0 si se equivoca en una opción al digitar algo en el menú principal, evitando tener que
tomar todas las medidas, como muchas otras correcciones de errores del programa.

7. CONCLUSIÓN.

Con este trabajo podemos concluir que gracias a las experiencias adquiridas en el curso de
algoritmia y programación, se logró el profundo aprendizaje de los objetivos propuestos al
inicio del curso, además de lograr poner en práctica los temas analizados a lo largo de este
semestre y de muchas otras habilidades desarrolladas en nuestra carrera como el uso de
Arduino, el cálculo, y la investigación.

Al final del semestre pudimos demostrar estos conocimientos por medio de la creación del
proyecto integrador donde, de manera exitosa, se logró una conexión entre la programación
de un arduino uno y una programación en el programa python, haciendo uso de las diferentes
funciones aprendidas dentro de la programación en dicho software. Esto nos permitió pasar
de la teoría a la práctica, profundizando en la temática tratada.

8. Cibergrafía.

Pyserial:
https://www.luisllamas.es/controlar-arduino-con-python-y-la-libreria-pyserial/
Control ultrasonidos:
https://www.youtube.com/watch?v=RRpEXRyjYUs
control DHT22:
https://www.youtube.com/watch?
v=lvBb1Ue8OJ4&list=PLJqYkNvxJY5qPk_w_0ixex2pdzuWSoPp_&index=1&t=572s

Video de presentación:
https://youtu.be/HReyzz_8qF8