Tsu mecatrónica área automatización 4 A 204

Microcontroladores

ESP32
 ESP32
El ESP32 es un microcontrolador de bajo coste creado por
Espressif Systems. Destaca que posee tecnologías WiFi y
Bluetooth integradas y tecnología de bajo consumo. El
NodeMCU ESP32 es una plataforma completa de desarrollo,
módulo SoC (system on chip), basado en el microcontrolador Tensílica
de 32 bits, funcionando a una frecuencia de reloj de 240 Mhz, con una
memoria Flash de 4MB, y 500 KB de SRAM con un procesador de doble
núcleo de 32 bits.
 Especificaciones ESP32

• Placa: ESP32 DEVKIT V1 (Espressif)

• SoM (System on module): ESP-WROOM-32 (Espressif)
• SoC (System on chip): ESP32 (ESP32-D0WDQ6)
• Procesador: Tensilica Xtensa Dual-Core 32-bit LX6.
• Frecuencia del reloj: 160 a 240 Mhz.
• Desempeño: Hasta 600 DMIPS
• Memoria:
❑ • 448 KByte ROM
❑ • 520 KByte SRAM
❑ • 16 KByte SRAM in RTC (Real Time Clock)
❑ • QSPI Flash/SRAM, 4 MBytes
• Número total de pines GPIO: 25
• WiFi con antena integrada: estándar 802.11 b/g/n. Velocidad
de 150.0 Mbps
 Especificaciones ESP32
•

• Bluetooth: BLE (Bluetooth Low Energy) y Bluetooth Classic

• Interfaz USB-Serial CP2102 on board.
• Modo de funcionamiento Low Power.
• Peripheral Input/Output (25 pines GPIO)
• ADCs (Convertidores Analógico Digital) de 12 bits
• DACs (Convertidores Digital Analógico) de 8 bits
• I²C (Inter-Integrated Circuit)
• UART (Universal Asynchronous Receiver/Transmitter)
• SPI (Serial Peripheral Interface)
• I²S (Integrated Interchip Sound)
• RMII (Reduced Media-Independent Interface)
• PWM (Pulse-Width Modulation).
• Regulador de 3.3 volts on board.
• Voltaje de Alimentación (USB): 5V DC
• Niveles de voltaje de entradas/salidas: 3.3v CD
Diagrama de bloque
Diagrama de pines
 MicroPython
Micro Python es una re-implementación del lenguaje Python
específicamente de la versión 3.4 para microcontrolares, fue
desarrollado por el programador australiano Damien P George y este
lenguaje no posee todas las librerías estándar que lleva Python. la
ventaja de usar MicroPython es la facilidad del lenguaje. Se pueden
utilizar distintos IDE como uPyCraft PyCharm o EsPy, Thonny y Visual
Studio Code. En nuestro caso utilizaremos el ide Thonny
 Primeros pasos con MicroPython en IDE THONNY

Los pasos para poder utilizar la programación en micropython para el

microcontrolador ESP32 debemos realizar primero los siguientes
pasos:
1. Instalación de Python 3.8.x en Windows
2. Instalación de IDE Thonny
3. Actualización del firmware de MicroPython (archivo bin) en la
placa MakePython ESP32
4. Escritura de código de Python y carga del código en ESP32 usando
IDE Thonny
 Paso 1: Instalar Python en Windows
• MicroPython es una implementación de Python, por lo que primero
debemos instalar Python 3 para ello nos dirigimos a la pagina
oficial de Python y descargamos la versión acorde a nuestro
sistema operativo el link se pone a continuación para la descarga
de Python. Link para descargar PYTHON https://www.python.org
 Paso 1: Instalar Python en Windows

Después de descargar Python se debe instalarla como se muestra en

la siguiente figura
 Paso 2. Instalar Thonny IDE
Para la instalación del IDE entramos a la pagina de Thonny el link es
el siguiente: Link para descargar PYTHON https://thonny.org/
 Paso 2. Instalar Thonny IDE
Una vez descargado procedemos a instalar Thonny
 Paso 3: Instalar controladores
en Windows

para que nuestro sistema operativo reconozca el microcontrolador

ESP32 requerimos los controladores para ello descargamos en la
pagina oficial que es la siguiente: Link para descargar drivers
https://micropython.org/download/#esp32
 Paso 3: Instalar controladores
en Windows

una vez descargados los drivers conectamos nuestro dispositivo por

USB y seleccionamos la ruta donde descargamos los archivos y nos
debe aparecer como la siguiente imagen
 Paso 4: Instalar firware
A tarjeta ESP32

lo siguiente que requerimos es descargar el firmware para la placa para ello

revisamos la versión de nuestra placa y ingresamos a la pagina oficial para descargar
la versión acorde a nuestro microcontrolador en la siguiente pagina:
Link para descargar Firmware¶ https://micropython.org/download/#esp32
 Paso 4: Instalar firware
A tarjeta ESP32

después de descargar el firmware abrimos el IDE Thonny

seleccionamos la placa como se muestra en la siguiente imagen
 Paso 4: Instalar firware
A tarjeta ESP32
seguimos a acargar el puerto y firware para nuestra praca como se
muestran en las imágenes siguientes
Paso 4: Instalar firware
A tarjeta ESP32
 Paso 3: Instalar controladores
en Windows

Le damos en el botón inferior a instalar y presionamos el botón boot

de nuestra placa para iniciar la instalación. Una vez instalado el firware
nos debe aparecer como en la siguiente imagen
Iniciando IDE Thonny
 Iniciando con Python

Python es un lenguaje de programación potente y fácil de aprender.

Tiene estructuras de datos de alto nivel eficientes y un simple pero
efectivo sistema de programación orientado a objetos.
Con el fin de que este curso sea practico se vera la teoría para realizar
la práctica y los requisitos necesarios para su implantación de manera
física en la placa ESP32.
 BIT Salida practica 1
El primer programa que realizaremos será el encendido de un led el
cual se encenderá y después de un segundo se apague. Físicamente la
placa ESP32 en el bit 2 trae integrado un LED y será el que
utilizaremos para este ejemplo, tan solo requerimos conectar nuestra
placa y realizar el código para posterior encender y apagar el LED
Para ello requerimos:
el comando “from” selecionamos la librería y con “import”
importamos la librería. el siguiente código en Python nos permite
seleccionar de la librería “machine” importar “Pin” con esta librería
nos permite manejar el GPIO de nuestro microcontrolador ESP32 s a
continuación se muestra el código

from machine import Pin

 BIT Salida practica 1
también para poder realizar retardos requerimos importar la librería
de “time” para ello escribimos el siguiente código

from time import sleep_ms

las anotaciones dentro del código es muy útil para identificar nuestro
código para poder escribir comentarios en Python utilizamos “#”
seguido del comentario que deseamos como ejemplo el siguiente

from time import sleep_ms # importamos sleep_ms

#esta libreria nos permite manejar el GPIO del ESP32
from machine import Pin #importamos libreria pin
 BIT Salida practica 1
Para poder manejar los bit del GPIO requerimos primero declarar el uso
si es salida o entrada el comando que se utiliza es
“Pin(bit,Entrada o Salida)” para efecto de nuestro
ejemplo utlizaremos como salida como se muestra el siguiente código
#con Pin(no_bit,Pin.OUT) .OUT es como salida
led=Pin(2,Pin.OUT) #el bit 2 como salida digital

El comando para retardo esta dado por milisegundo y es el siguiente

comando “sleep_ms(tiempo en milisegundo)”

sleep_ms(1000) #retardo de 1 segundo

 BIT Salida practica 1
También requerimos encender y apagar el LED y la instrucción que
nos permite realizar esto es “bit.value(estado)” estado si es
1 esta en alto y si el estado es 0 esta en bajo

led.value(1) #ensendemos el LED

led.value(0) #apagamos el led
 BIT Salida practica 1
nuestro código completo para el ejemplo 1 nos quedaría como a
continuación
from machine import Pin #libria para GPIO
from time import sleep_ms #libreria para retardos
led=Pin(2,Pin.OUT) #bit 2 como slida

led.value(1) #LED encendido

sleep_ms(1000) #retardo de 1 segundo
led.value(0) #LED apagado
sleep_ms(1000) #retardo de 1 segundo
 BIT Salida practica 1
Una vez terminado de escribir nuestro código procedemos a guardar el
archivo en nuestra PC para ello en el IDE Thonny en la pestaña de
archivo seleccionamos Guardar como y colocamos el nombre del
código con terminación .py como se muestra en la imagen siguiente
 BIT Salida practica 2
En este ejemplo queremos que el led se encienda por un segundo y
se apague un segundo repitiéndose esta operación de manera
continua. ahora requerimos hacer ciclos infinito para hacerlo de
manera continua las instrucciones de encendido como apagado del
LED y la instrucción que me permite realizar esto el “while”
mientras sea verdadera con el argumento “True” se ejecuta , funciona
de la siguiente manera las líneas de código que esten por debajo de la
instrucción con un espacio se ejecutaran mientras sea verdadero la
condición de “while” como se muestra en el código siguiente.

while True:
codigo #se ejecuta mientras sea verdad
codigo
 BIT Salida practica 2
nuestro código completo para el ejemplo 2 nos quedaría como a
continuación
from machine import Pin #libria para GPIO
from time import sleep_ms #libreria para retardos
led=Pin(2,Pin.OUT) #bit 2 como slida

while True:
led.value(1) #LED encendido
sleep_ms(1000) #retardo de 1 segundo
led.value(0) #LED apagado
sleep_ms(1000) #retardo de 1 segundo
 BIT Entrada practica 3
Comando if
Empezaremos con explicar la sentencia “if” la cual se cumple si la
expresión evaluada, resulta ser verdadera(True), entonces ejecuta una
vez el código en la expresión. Si sucede el caso contrario y la expresión
es falsa, entonces No ejecutes el código que sigue." El “if” esta
seguido de la sentencia “else” cuyo significado es de ser falso el if
ejecta lo siguiente. A continuación se muestra como ejemplo el uso
en Python

if variable()==1: #preguntamos si el pulsador es igual a 1

líneas de código #si es verdadero ejecuta este codigo

else: #de lo contrario ejecuta el codigo

líneas de codigo #si es falso ejecutamos este codigo

 BIT Entrada practica 3
El objetivo de este ejemplo es comprender el control de flujo del
programa con la sentencia “if” y la declaración de un bit de entrada
para el ESP32. Lo primero que aremos es armar el circuito como se
muestra en la imagen siguiente
 BIT Entrada practica 3
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
03 Entrada digital
 practica 4 PWM
Esta práctica tiene como objetivo enseñar la entrada de datos
proporcionados por el usuario en consola como la utilización del
manejo de flujo del programa así como el uso de la modulación
anchura de pulsos para ello realizaremos un programa que trabaje con
el PWM ingresando por el usuario los datos en consola para el ciclo de
trabajo del PWM y de introducir la palabra “fin” se terminara la
ejecución del programa.
 practica 4 PWM
La modulación de ancho de pulso (PWM) es una forma de obtener una
salida analógica artificial en un pin digital. Lo logra cambiando
rápidamente el pin de bajo a alto. Hay dos parámetros asociados con
esto: la frecuencia del cambio y el ciclo de trabajo. El ciclo de trabajo
se define como el tiempo que el pin está alto sumado con el tiempo en
bajo lo cual es un solo período (tiempo bajo más tiempo alto). El ciclo
de trabajo máximo es cuando el pin está alto todo el tiempo, y el
mínimo es cuando está bajo todo el tiempo.
 practica 4 PWM
La señal PWM (Modulación por Ancho de Pulso) es una señal periódica
configurable donde se puede modificar el ciclo de trabajo para que
trabaje un determinado tiempo en Encendido o 3.3v y el resto de
tiempo en Apagado o 0v, y repita este procedimiento infinitamente,
pudiendo variar este ancho de pulso en cualquier instante.
 practica 4 PWM

Esto es interesante, porque el voltaje medio que se le aplica a la carga

es proporcional al tiempo que la señal se mantuvo en 3.3v y con esto
podemos lograr varias aplicaciones como controlar la luminosidad de
un LED, la velocidad de un motor, regular resistencias calefactoras a
través de relés de estado sólido, controlar un servomotor . Para
configurar un pin PWM en micropython necesitamos importar la clase
PWM y la clase Pin del módulo machine.
 practica 4 PWM
En Python importamos la librería PWM y creamos la instancia o objeto
con el método PWM para crear un objeto PWM, debemos pasar como
parámetros, el pin vamos a configurar, la frecuencia de la señal y el
ciclo de trabajo como en el código siguiene

from machine import Pin,PWM #importamos la libreria Pin y PWM

#definicion del objeto para PWM

# PWM(bit a usar, frecuencia, trabo)
pwm = PWM(Pin(23),freq=500,duty=0)
 practica 4 PWM
En ESP32 la frecuencia por defecto está configurada a 1khz, el ciclo de
trabajo puede tener un valor entre 0 y 1023. En el cual 1023
corresponde al 100% del ciclo de trabajo (brillo total) y 0 corresponde
al 0% del ciclo de trabajo (LED apagado) Para configurar el ciclo de
trabajo, usamos el método “duty()” del objeto PWM creado y como
parámetro de entrada le definimos el ciclo de trabajo deseado

#asecta de 0 a 1023 en caso de ser mayor de 1023 se va a 0

objeto.duty(ciclo de trabajo) #coloca el ciclo de trabajo
 practica 4 PWM
En ESP32 la frecuencia por defecto está configurada a 1khz, el ciclo de
trabajo puede tener un valor entre 0 y 1023. En el cual 1023
corresponde al 100% del ciclo de trabajo (brillo total) y 0 corresponde
al 0% del ciclo de trabajo (LED apagado) Para configurar el ciclo de
trabajo, usamos el método “duty()” del objeto PWM creado y como
parámetro de entrada le definimos el ciclo de trabajo deseado

#asecta de 0 a 1023 en caso de ser mayor de 1023 se va a 0

objeto.duty(ciclo de trabajo) #coloca el ciclo de trabajo
 practica 4 PWM
el comando que permitirá liberar el bit en modo PWM es el siguiente
codigo

objeto.deinit() #libera el bit como pwm

el comando “input(“mensaje impreso en consola”)” para la entrada

de consola se requiere escribir el MSN encerrado en comillas dobles y
después espera la entrada en la consola como se muestra en el código
siguiente
#este comando imprime un mensaje y espera la
respuesta del usuario
#para grabar el dato en la variable “a”
a = input("Digite el Ciclo de trabajo: ")
 practica 4 PWM
Comando para la salida de consola “print(“mensaje a imprimir en
consola”)” se muestra el ejemplo en el siguiente código

#imprime en la consola el MSN “Fin de Programa”

print("Fin de Programa") #imprime en consola
 practica 4 PWM

Para este ejemplo utilizaremos el GPIO 23 del microcontrolador

ESP32 para ello armamos un circuito como se muestra en la siguiente
imagen
 practica 4 PWM
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
04 PWM
 practica 5 ADC
Como objetivo de la practica es trabajar la librería ” math” para
realizar operaciones matemáticas, utilizar el convertidor analógico
digital ADC del ESP32 como la utilización de conversión de variables
numéricas a cadena de texto con el comando “str(variable)” para ello
realizaremos el siguiente programa que cumpla la conversión ADC del
BIT 36 y lo despliegue en la consola de manera continua.
Antecedentes: La Conversión Analógica-Digital (Conversión A/D o ADC
-Analog-Digital Coversion-) consiste en la transcripción de señales
analógicas a digitales, con el propósito de facilitar su procesamiento.
Para ello se realizan medidas de la amplitud de la señal y se redondean
sus valores a un conjunto finito de niveles preestablecidos –niveles de
cuantificación-, para poder registrarlos. El microcontrolador ESP32
puede leer la tensión y realizar la conversión ADC en los pines 32, 33,
34, 35, 36, 37, 38 y 39.
 practica 5 ADC
Como objetivo de la practica es trabajar la librería ” math” para
realizar operaciones matemáticas, utilizar el convertidor analógico
digital ADC del ESP32 como la utilización de conversión de variables
numéricas a cadena de texto con el comando “str(variable)” para ello
realizaremos el siguiente programa que cumpla la conversión ADC del
BIT 36 y lo despliegue en la consola de manera continua.
Antecedentes: La Conversión Analógica-Digital (Conversión A/D o ADC
-Analog-Digital Coversion-) consiste en la transcripción de señales
analógicas a digitales, con el propósito de facilitar su procesamiento.
Para ello se realizan medidas de la amplitud de la señal y se redondean
sus valores a un conjunto finito de niveles preestablecidos –niveles de
cuantificación-, para poder registrarlos. El microcontrolador ESP32
puede leer la tensión y realizar la conversión ADC en los pines 32, 33,
34, 35, 36, 37, 38 y 39.
 practica 5 ADC
La clase ADC de la librería machine –machine.ADC()– proporciona la
interfaz para la conversión y dispone de 4 métodos (funciones):
• ADC.read(): lee el voltaje (tensión).
• ADC.read_u16(): lee el voltaje, con una precisión de 16 bits.
• ADC.atten(): permite atenuar el voltaje a leer, para incrementar el
intervalo de 0V – 1V para el que está preparado el
microcontrolador.
• ADC.width: permite regular la precisión de lectura de ADC.read().
 practica 5 ADC
Nota
No se debe olvidar que el voltaje máximo de entrada para los pines del
microcontrolador es de 3.6v. Superar este límite puede dañarlo.
Si no se modifican la atenuación ADC.atten() ni la precisión de lectura
ADC.width(), por defecto la atenuación será de 0 dB y la precisión de
12 bits. Permitirá lecturas en el intervalo de 0.0 V a 1.0 V, obteniendo
valores entre 0 y 4.095 (212=4.096). Cualquier voltaje por encima de
1.0 V dará como resultado 4095.
 practica 5 ADC
Método ADC.atten() El método ADC.atten(atenuación) permite
atenuar del voltaje a leer, conforme a unos valores establecidos, para
incrementar el voltaje máximo de lectura. Se debe tener en cuenta que
conforme se incrementa la atenuación se reduce precisión de lectura.
Los posibles valores de atenuación son:
• ADC.ATTN_0DB: 0 dB de atenuación. Permite un rango de lectura
entre 0.0 V y 1.0 V -es la configuración por defecto-.
• ADC.ATTN_2_5DB: 2.5 dB de atenuación. Permite un rango de
lectura entre 0.0 V y 1.34 V.
• ADC.ATTN_6DB: 6 dB de atenuación. Permite un rango de lectura
entre 0.0 V y 2.0 V.
• ADC.ATTN_11DB: 11 dB de atenuación. Permite un rango de lectura
entre 0.0 V y 3.6 V.
 Ejemplo 5 ADC
Método ADC.width() El método ADC.width(ancho) permite establecer
el número de bits que se utilizarán y devolverán durante las lecturas de
ADC. Las posibles valores de ancho son:
• ADC.WIDTH_9BIT: 9 bits. 29=512 ⇒ valores entre 0 y 511.
• ADC.WIDTH_10BIT: 10 bits. 210=1.024 ⇒ valores entre 0 y 1023.
• ADC.WIDTH_11BIT: 11 bits. 211=2.048 ⇒ valores entre 0 y 2047.
• ADC.WIDTH_12BIT: 12 bits. 212=4.096 ⇒ valores entre 0 y 4095 -es
la configuración por defecto-.
 practica 5 ADC
Nota
No se debe olvidar que el voltaje máximo de entrada para los pines del
microcontrolador es de 3.6v. Superar este límite puede dañarlo.
Si no se modifican la atenuación ADC.atten() ni la precisión de lectura
ADC.width(), por defecto la atenuación será de 0 dB y la precisión de
12 bits. Permitirá lecturas en el intervalo de 0.0 V a 1.0 V, obteniendo
valores entre 0 y 4.095 (212=4.096). Cualquier voltaje por encima de
1.0 V dará como resultado 4095.
 practica 5 ADC
a continuación procedemos a configurar el ADC del ESP32 en Python
para ello escribimos los siguientes comandos como se muestra en el
código siguiente

from machine import ADC #importamos las librerias

import math #para hacer operaciones matematicas

adc = ADC(Pin(36)) #declaramos un objeto para manejar ADC

#configuramos la conversion a 3.3V

adc.atten(ADC.ATTN_11DB)
# Nota como no especifico la resoluccion por defecto toma a 12 bit
#0 a 4096
# lee la conversion de ADC y la depositamos en a

a = adc.read()
 practica 5 ADC
el comando que nos permite convertir una variable a string es
“str(variable)” debido a que la impresión en la consola requerimos
string y la conversión nos entrega una variable int requerimos para su
visualización la conversión de dicha variable como se muestra en el
código de continuación.
#str() convierte a string (cadena de texto)
# imprime en consola el valor en string

print("Valor leido: "+str(b))

 practica 5 ADC
Implementamos el siguiente circuito como se muestra a continuación
 Practica 5 ADC
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
05 ADC.py
 Practica 6 LM35
El objetivo de la practica es conectar el sensor LM35 y revisar las
especificaciones de su datasheet para conectarlo al GPIO36 para
realizar la traducción de temperatura, para ello se requiere realizar
un programa que de manera continua este obteniendo la temperatura
del ambiente y la imprima en la consola del IDE Thonny.
 Practica 6 LM35
El LM35 es un sensor de temperatura con su salida analógica en
voltaje. El sensor tiene un rango desde −55°C a 150°C. el LM35
proporciona 10mV por cada grado centígrado entregando una salida
línea como se muestra en su datasheet en la siguiente figura
 Practica 6 LM35
A continuación se muestra las terminales del dispositivo según su
datasheet
 Practica 6 LM35
Procedemos a realizar el siguiente circuito como se muestra a
continuación.
 Practica 6 LM35
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
06 LM35.py
 Practica 7 ADC y PWM
el objetivo de esta practica es relacionar el convertidor analógico y
digital con PWM en esta practica capturaremos la conversión ADC de
un potenciómetro para colocar la intensidad de un LED .
las consideraciones que debemos tener con el ADC es que la
conversión es a 12 bits y tenemos de o a 4096 y el PWM solo me
permite de 0 a 1023 para ello truncamos la conversión del ADC
como es 4 veces mayor que lo permitido en el PWM lo dividimos entre
4 para que sea escalado el ADC con PWM con el siguiente codigo

b = math.trunc(a/4) #nos permite truncar la variable

 Practica 7 ADC y PWM
Procedemos a realizar el siguiente circuito como se muestra a
continuación.
 Practica 7 ADC y PWM

Descripción de pines:
Vcc: Pin de alimentación. (5V)
Trigger: Pin de disparo. Este pin es una entrada, por lo que en el sistema
de control, se tiene que conectar a una salida.
Echo: Este pin es una salida del sensor, por lo que ha de ser conectado a
una entrada del sistema de control.
Gnd: Pin negativo de alimentación.
 Practica 8 HC-SR04
Objetivo de la practica es aprender a manejar diferentes sensores con
la implementación de librerías de código abierto
El sensor HC-SR04 esta compuesto por un emisor y un receptor de
ultrasonidos. Estos nos ayuda a medir la distancia a la que se
encuentra un objeto justo frente a el, enviando un pulso de sonido
ultrasonidos y midiendo el tiempo que transcurre hasta el regreso el
mismo
 Practica 8 HC-SR04

Características eléctricas:
Voltaje de trabajo: 5V.
Corriente de trabajo: 15mA.
Frecuencia de trabajo: 40KHz
Rango de funcionamiento: 2 a 500 cm
Ángulo de detección: 15 a 20 grados.
 Practica 8 HC-SR04
funcionamiento:
Se aplicar un pulso de 10uS en el pin trigger para comenzar con la
medición, A continuación el sensor envía una serie de 8 pulsos de
40KHz y pone el pin de Echo a nivel alto. El pin Echo permanecerá a
nivel alto hasta que se reciba el eco de los pulsos de 40KHz. Para saber
a la distancia a la que se encuentra el objeto, solo hay que medir el
tiempo al que está el pin Echo a nivel alto.
 Practica 8 HC-SR04
Link de descarga para la librería del sensor ultrasónico

https://github.com/JVH93/Micros_ITLM/tree/HCSR04
 Practica 8 HC-SR04
Lo siguiente es bajar la librería del sensor ultrasónico HCSR04 para ello
el Link de descarga para la librería es el siguiente:
https://github.com/JVH93/Micros_ITLM/tree/HCSR04
procedemos a cargar la librería a la placa ESP32
como se muestra en la imagen de continuación primero
en el menú de visualización activamos archivos.
 Practica 8 HC-SR04
Una vez visualizado navegamos a la carpeta de
librería y le damos clip derecho sobre la librería
“hcsr04” y le damos subir al como se muestran en
las imágenes siguientes
 Practica 8 HC-SR04
Las funciones para manejar la librería son las siguientes:
objeto.distance_cm(): optine la distancia en centrimetros
“HCSR04(trigger_pin=5, echo_pin=18,
echo_timeout_us=1000000)” declara el objeto de
conexión con los parametors de los bits asocciados al
ESP32
A continuación se muestra el código de ejemplo para la
configuración del sensor ultrasónico HSCR04

from hcsr04 import HCSR04 #importa la librería del sensor

ultrasonico
#decraramos el objeto sensor y definimos los bits de la conexión
# la relacion de bit con los pines del ESP32 con el sensor HSCR04
sensor = HCSR04(trigger_pin=5, echo_pin=18, echo_timeout_us=1000000)
distance = sensor.distance_cm()#obtiene la distacia en cm
 Practica 8 HC-SR04

Procedemos a realizar el siguiente circuito como se muestra a

continuación.
 Practica 8 HC-SR04
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
08 HC-SR04.py
 Practica 9 DHT11
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
09 DHT11.py
 Practica 9 DHT11
El objetivo de esta practica es obtener la conexión del
microcontrolador ESP32 con una libre que viene en micropython
precargada solo debemos importarla.
El módulo medidor de temperatura y humedad DHT11 posee en su
interior un conjunto de detectores de temperatura y humedad con una
salida calibrada de señal en formato digital. Mediante el uso de una
exclusiva técnica digital de adquisición de señales garantiza una alta
confiabilidad y una excelente estabilidad a largo plazo. Este sensor
incluye un componente de medición de humedad de tipo resistivo, y
un componente de medición de temperatura NTC conectados a un
microcontrolador de 8 bits de alto rendimiento, lo que ofrece
excelente calidad, rentabilidad, respuesta rápida y capacidad anti-
interferencias.
 Practica 9 DHT11
La interfaz serie de un solo cable hace que la integración del sistema sea rápida y
sencilla. proceso general de comunicación, cuando el MCU envía una Señal de Inicio,
el DHT11 cambia del Modo de Bajo Consumo de Energía al Modo de Ejecución, y
espera a que termine la señal de inicio del MCU. Una vez que ésta se completa, el
DHT11 envía al MCU una señal de respuesta que contiene los 40 bits de datos con la
información sobre la temperatura y la humedad relativa. Una vez que se han obtenido
los datos, el DHT11 cambiará al Modo de Bajo Consumo de Energía hasta que reciba
de nuevo una señal de inicio del MCU.
 Practica 9 DHT11
distribución de pines del sensor DHT11 se muestran en la siguiente
figura
 Practica 9 DHT11
Agregar la librería al microcontrolador ESP32 de la siguiente
manera

import dht #importamos la libreria de dht

s = dht.DHT11(Pin(15)) #definimos el pin 15 para cumunicar el

#sensor DHT11

#obtiene la temperatura y humedad del sensor

s.measure()
# imprimimos en la consola
print("T="+str(s.temperature())+"
H="+str(s.humidity()))
 Practica 9 DHT11

Procedemos a realizar el siguiente circuito como se muestra a

continuación.
 Practica 9 DHT11
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
09 DHT11.py
 Practica 10 LCD I2C
Objetivo de la practica es la visualización de los datos en una pantalla
LCD con la utilización de la librería adecuada, para esta practica
utilizaremos la conexión serial I2C. El Módulo adaptador LCD a I2C que
usaremos está basado en el controlador I2C PCF8574, el cual es un
Expansor de Entradas y Salidas digitales controlado por I2C. Por el
diseño del PCB este módulo se usa especialmente para controlar un LCD
Alfanumérico. La dirección I2C por defecto del módulo puede ser 0x3F
o en otros casos 0x27. Es muy importante identificar correctamente la
dirección I2C de nuestro modulo, pues de otra forma nuestro programa
no funcionará correctamente.
 Practica 10 LCD I2C
El software I2C (usando bit-banging) funciona en todos los pines con
capacidad de salida y se accede a través de la clase machine.SoftI2C :
Para conectar con el modulo con el ESP32 solo utilizamos los pines I2C
del ESP32 (SDA y SCL) y alimentación (GND y 5V), los pines I2C varían de
acuerdo al modelo
 Practica 10 LCD I2C
Link de descarga para la librería del LCD I2C

https://github.com/dhylands/python_lcd
 Practica 11 LCD I2C
Se procede a cargar las librerías esp8266_i2c_lcd.py y lc_api.py en el
microcontrolador Esp32 como se muestra en la imagen siguiente
 Practica 10 LCD I2C
El software I2C (usando bit-banging) funciona en todos los pines con
capacidad de salida y se accede a través de la clase machine.SoftI2C :
Para conectar con el modulo con el ESP32 solo utilizamos los pines I2C
del ESP32 (SDA y SCL) y alimentación (GND y 5V), los pines I2C varían de
acuerdo al modelo
 Practica 10 LCD I2C
el siguiente código es para configurar el LDC i2c, también se muestran los diferentes
comandos para la utilización del LCD
from machine import SoftI2C, Pin
from esp8266_i2c_lcd import I2cLcd

# The PCF8574 has a jumper selectable address: 0x20 - 0x27 3F

DEFAULT_I2C_ADDR = 0x27
#definimos I2C la coneccion y frecuencia
i2c = SoftI2C(scl=Pin(22), sda=Pin(21), freq=100000)
#definimos nuestro lcd
lcd = I2cLcd(i2c, DEFAULT_I2C_ADDR, 2, 16)
lcd.clear() #limpia LCD
lcd.move_to(0, 0) # se coloca en la columna 0 fila 0
lcd.putstr("LCD_I2C y ESP32") #imprime mensaje en LCD
 Practica 10 LCD I2C
Procedemos a realizar el siguiente circuito como se muestra a
continuación.
 Practica 10 LCD i2c
• En esta practica realizaremos el corrimiento de texto utilizando el
mismo circuito de la practica 10 para ello utilizademos la instrucción
“lcd.move_to(posicion)” lo que aremos moveremos y
limpiamos el LCD para volver a escribir el texto para crear la ilusión
de movimiento de texto. Para este programa se realiza le solución
con el siguiente codigo.
 Practica 11 LCD i2c corrimiento
En IDE Thonny le damos abrir archivo y nos dirigimos a la carpeta de
de código y cargamos el siguiente programa:
11 LCD i2c corrimiento.py