TikTok
Resumen
Convierte tu tarjeta DualMCU ESP32 + RP2040 en un completo velocímetro GPS utilizando un módulo GPS y una pantalla OLED I2C de 0.96 pulgadas. En este proyecto aprenderás paso a paso cómo aprovechar la potencia del microcontrolador RP2040 para obtener información en tiempo real, como la velocidad, las coordenadas geográficas, la intensidad de la señal y otros datos proporcionados por los satélites.
A lo largo del tutorial veremos cómo realizar las conexiones del hardware, configurar el entorno de desarrollo, instalar las librerías necesarias y programar el sistema para mostrar diferentes pantallas de información que cambiarán automáticamente cada pocos segundos.
Entre las funciones principales del proyecto destacan:
- Medición de velocidad en tiempo real mediante GPS.
- Visualización de coordenadas de latitud y longitud.
- Información sobre la calidad de la señal y los satélites disponibles.
- Integración con mapas mediante enlaces a la ubicación actual.
- Interfaz gráfica sencilla utilizando una pantalla OLED I2C.
- Programación con MicroPython.
Este proyecto es ideal para quienes desean iniciarse en el mundo de los sistemas embebidos, el Internet de las cosas (IoT) y la navegación por satélite, además de servir como base para desarrollar aplicaciones más avanzadas, como rastreadores GPS, computadoras de viaje o sistemas de telemetría.
Introducción
Para este velocímetro usaremos nuestra tarjeta de desarrollo DualMCU que destaca por tener dos microcontroladores de las generaciones más usadas, la ESP32 y el RP2040, pero además incluiremos el ATGM336H Modulo GPS + BDS Beidou, el cual es un módulo que por su tamaño ofrece muchas ventajas en funcionamiento, así que antes de comenzar con el proceso, nos hará bien repasar algunas características de estos, recuerda que todo lo podrás encontrar con nosotros en UNIT Electronics.
DualMCU ESP32 + RP2040 – UNIT DevLab.
La DualMCU ESP32 + RP2040 – UNIT DevLab es una tarjeta de desarrollo que integra dos microcontroladores en una sola plataforma: el ESP32 de Espressif y el RP2040 de Raspberry Pi. Esta combinación permite aprovechar las capacidades inalámbricas del ESP32 y la potencia de procesamiento del RP2040 para desarrollar proyectos electrónicos avanzados.
La principal característica de esta tarjeta es su arquitectura DualMCU, que combina las ventajas de ambos microcontroladores:
- ESP32: proporciona conectividad Wi-Fi y Bluetooth para aplicaciones de Internet de las cosas (IoT).
- RP2040: ofrece un alto rendimiento para el procesamiento de datos y el control de periféricos.
Gracias a esta arquitectura, es posible distribuir tareas entre ambos procesadores para optimizar el rendimiento del sistema.
Interfaces y Conectividad.
La DualMCU incorpora diversas interfaces de comunicación que facilitan la conexión con sensores y dispositivos externos:
- UART.
- I2C.
- SPI.
- PWM.
- ADC y GPIO programables.
- Wi-Fi y Bluetooth.
Además, cuenta con un puerto USB Tipo C, ranura para tarjeta microSD y conectores de expansión que amplían sus posibilidades de uso.
Compatibilidad en Entornos de Desarrollo.
La tarjeta es compatible con diferentes plataformas de programación, lo que la convierte en una excelente opción tanto para principiantes como para usuarios avanzados:
- Arduino IDE.
- MicroPython.
- Thonny.
- Visual Studio Code.
Esta compatibilidad permite desarrollar proyectos de electrónica, automatización, robótica e Internet de las cosas utilizando el entorno de programación que mejor se adapte a cada necesidad.
ATGM336H Modulo GPS + BDS Beidou.
El ATGM336H es un módulo de posicionamiento satelital compatible con los sistemas GPS y BDS (BeiDou), diseñado para proporcionar información precisa sobre la ubicación, velocidad y tiempo en tiempo real. Gracias a su tamaño compacto y bajo consumo energético, es ampliamente utilizado en proyectos de navegación, seguimiento y sistemas embebidos.
Una de las principales características del ATGM336H es su capacidad para recibir señales de diferentes constelaciones satelitales. Al combinar la red GPS con el sistema BeiDou, el módulo ofrece una mayor precisión y estabilidad en la ubicación, incluso en zonas urbanas o con obstáculos que dificultan la recepción de la señal.
Datos Proporcionados por el Módulo.
El módulo es capaz de proporcionar una gran variedad de datos útiles para proyectos de geolocalización, entre los que destacan:
- Latitud y longitud.
- Velocidad de desplazamiento.
- Altitud.
- Fecha y hora.
- Número de satélites conectados.
- Calidad e intensidad de la señal.
La comunicación entre el ATGM336H y el microcontrolador se realiza a través de una interfaz UART, permitiendo una integración sencilla con plataformas como Arduino, ESP32 y RP2040. La información se transmite utilizando el protocolo NMEA, un estándar ampliamente utilizado en dispositivos de navegación y geolocalización.
Aplicación en el Proyecto.
En este proyecto utilizaremos el módulo ATGM336H junto con la tarjeta DualMCU ESP32 + RP2040 y una pantalla OLED I2C para desarrollar un velocímetro digital capaz de mostrar información en tiempo real, como la velocidad, las coordenadas geográficas y el estado de la señal satelital.
Ahora que ya sabemos que función tendrá cada uno de estos dos componentes principales para nuestro velocímetro, podemos agregar todos los demás materiales que vamos a usar, que en esta ocasión serán pocos, por lo que podrás hacerlo hasta para practicar tus habilidades y aprender algo nuevo.
Materiales
- DualMCU ESP32 + RP2040 – UNIT DevLab.
- ATGM336H Modulo GPS + BDS Beidou.
- Display Oled Azul 128×64 0.96″ I2C SSD1315.
- Cables Dupont Cortos 10cm HH.
- Cable USB Tipo C 3A 6A.
- PC/Ordenador.
Si deseas comprar todo sin necesidad de buscar producto por producto, ingresa a la Lista de Deseos, encontrarás cada uno de los materiales, listo para que solo agregues y compres.
Diagrama de Conexión
Ya que tienes tus componentes electrónicos de la mejor tienda de electrónica en México, puedes pasar a armar este circuito, realmente, es sencillo, mi recomendación guíate de la siguiente imagen:
Como consejo, revisa dos veces tus conexiones, la serigrafía de la DualMCU viene abajo, así que vale la pena asegurarse que conectaste cada pin en el lugar correcto, sigue mi consejo. Aunque la DualMCU se puede programar en diferentes entornos de desarrollo, como el clásico de Arduino IDE, en está ocasión lo haremos a través del software Thonny.
Requerimientos Previos
Para el proyecto del velocímetro, usaremos el IDE de Thonny, a continuación, te enseñaré a configurarlo para la DualMCU.
Software y Configuración de Interprete.
En el siguiente enlace podrás descargar el firmware para poder desarrollar tus prácticas en Thonny: Firmware Thonny. Posteriormente a la instalación pasaremos a la configuración del ambiente.
Ahora realizaremos el cambio del switch en posición A para iniciar la UNIT DualMCU con el microcontrolador RP2040.
Dirígete a “Ejecutar” -> “Configurar interprete” para completar la configuración.
Se abrirá una ventana y tendremos que seleccionar el siguiente interprete:
En este punto deberás conectar tu DualMCU, en caso de que no la detecte, puedes desconectarla, e intentar de nuevo, pero está vez mantén presionado el BOOT del RP2040; lo detectará como un disco extraíble, sin embargo, vuelve a desconectar/conectar y listo aparecerá un COM.
Seleccionamos el puerto en que nuestra PC haya reconocido al RP2040:
Y ahora, a la par que das clic a “Instalar o actualizar MicroPython”, presionaremos el botón de BOOT para RP2040 y sin dejar de presionar daremos clic a “Instalar o actualizar MicroPython”:
Realiza la siguiente configuración e instala:
Finalmente, en la ventana principal de Thonny podrás observar que el RP2040 aparece como opción para trabajar. Ten en cuenta que el puerto COM es asignado por la máquina y puede variar.
Si has llegado hasta este punto, ya tendrás actualizada y configurada la DualMCU, sin embargo, para el proyecto, usaremos algunas librerías así que te enseñare el método para instalarlas.
Instalación de Librerías.
A continuación, te dejó una guía para la instalación de librerías:
- En la barra de herramientas de Thonny, seleccionar Gestionar paquetes:
- Colocar en el buscador el nombre de la librería a instalar:
- Selecciona la librería e instala.
Para nuestro velocímetro solo necesitaremos instalar la librería micropython-ssd1306, la cual nos servirá para nuestra pantalla OLED, es la única que usaremos y que no se tiene de forma predeterminada; ahora teniendo el IDE listo, junto con la configuración de nuestra tarjeta de desarrollo, pasemos a la parte más importante, nuestro código.
Código
A continuación, te muestro el código, con comentarios para que puedas analizar que hace cada segmento:
"""
========================================================================================================================
Nombre del archivo: GPS.py
Proyecto: UNIT Electronics Blog - Haz tú velocímetro con la DualMCU ESP32 + RP2040 y un DISPLAY OLED I2C
Área: Desarrollo
Autor: Gonzalo González
Fecha: 03/08/2026
========================================================================================================================
Descripción:
A través de la tarjeta de desarrollo DualMCU y con el microcontrolador RP2040 obtenemos la ubicación en coordenadas, ve-
locidad, altitud, número de satélites, etc., a través del módulo ATGM336H Modulo GPS + BDS Beidou. Esta ocasión se progra-
mo en MicroPython en el IDE de Thonny, para dar versatilidad al proyecto, además la información se está mostrando a través
de una pantalla OLED I2C.
========================================================================================================================
Conexión de Hardware
| ATGM336H | RP2040 |
| -------- | -----: |
| VCC | 3V3 |
| GND | GND |
| TX | GP9 |
| RX | GP8 |
| Pantalla OLED SSD1315 | UNIT DualMCU |
| --------------------- | -----------: |
| VCC | 3V3 |
| GND | GND |
| SDA | GP2 |
| SCL | GP3 |
========================================================================================================================
Desarrollado para UNIT Electronics / Desarrollo / Blog UNIT Electronics
========================================================================================================================
"""
from machine import UART, Pin, I2C
import ssd1306
import time
# =====================================================
# CONFIGURACIÓN OLED SSD1315
# Pantalla OLED 128x64 mediante comunicación I2C
#
# Conexiones:
# OLED SDA -> RP2040 GP2
# OLED SCL -> RP2040 GP3
# =====================================================
i2c = I2C(
1, # Usamos el bus I2C número 1 del RP2040
scl=Pin(3), # Pin de reloj I2C
sda=Pin(2), # Pin de datos I2C
freq=400000 # Velocidad I2C a 400 kHz
)
# Inicialización de la pantalla OLED
oled = ssd1306.SSD1306_I2C(
128, # Ancho de pantalla en píxeles
64, # Alto de pantalla en píxeles
i2c # Bus I2C utilizado
)
# =====================================================
# CONFIGURACIÓN GPS ATGM336H
#
# Conexiones:
# GPS TX -> RP2040 GP9
# GPS RX -> RP2040 GP8
#
# El GPS trabaja normalmente a 9600 baudios
# =====================================================
gps = UART(
1, # UART1 del RP2040
baudrate=9600, # Velocidad comunicación GPS
tx=Pin(8), # Pin TX del RP2040 hacia RX GPS
rx=Pin(9), # Pin RX del RP2040 desde TX GPS
timeout=1000 # Tiempo máximo espera lectura
)
# =====================================================
# VARIABLES DE DATOS GPS
#
# Aquí se almacenan los valores recibidos
# desde el módulo ATGM336H
# =====================================================
velocidad = 0.0 # Velocidad actual en km/h
latitud = "---" # Coordenada latitud
longitud = "---" # Coordenada longitud
altitud = "---" # Altura sobre nivel del mar
satelites = "---" # Cantidad de satélites conectados
rumbo = "---" # Dirección de movimiento en grados
estado = "BUSCANDO" # Estado del GPS (OK / SIN FIX)
antena = "OK" # Estado antena GPS
# =====================================================
# CONTROL DE CAMBIO DE PANTALLAS OLED
# La pantalla inicia siempre en:
# 0 = Velocidad
# Luego cambia automáticamente:
# 0 Velocidad, 1 Coordenadas,2 Google Maps,3 Datos GPS y 4 Señal GPS
# Cada pantalla dura 5 segundos
# =====================================================
pantalla = 0
ultimo_cambio = time.ticks_ms()
tiempo_pantalla = 5000
# =====================================================
# CONTROL DE INFORMACIÓN EN CONSOLA
# La consola de Thonny mostrará todos los datos GPS
# cada cierto tiempo para diagnóstico
# =====================================================
ultimo_serial = time.ticks_ms()
tiempo_serial = 2000
# =====================================================
# CONVERSIÓN DE COORDENADAS GPS
# El GPS entrega coordenadas en formato:
# 1924.46213,N
# donde:
# 19 = grados
# 24.46213 = minutos
# Esta función convierte el valor a grados decimales:
# 19.407702
# También cambia el signo para:
# S = negativo
# W = negativo
# =====================================================
def convertir_coordenada(valor, direccion):
try:
# Obtiene los grados completos
grados = int(float(valor) / 100)
# Obtiene los minutos restantes
minutos = float(valor) - (grados * 100)
# Convierte minutos a grados decimales
decimal = grados + (minutos / 60)
# Corrige hemisferio
if direccion == "S" or direccion == "W":
decimal *= -1
# Devuelve coordenada con 6 decimales
return round(decimal, 6)
except:
# Si hay error devuelve vacío
return "---"
# =====================================================
# PROCESAMIENTO DE DATOS GPS
# Esta función recibe cada línea enviada por el GPS
# Ejemplos:
# $GNRMC -> velocidad, posición y rumbo
# $GNGGA -> satélites y altitud
# =====================================================
def procesar_gps(linea):
global velocidad
global latitud
global longitud
global altitud
global satelites
global rumbo
global estado
try:
# Separamos la trama usando comas
datos = linea.split(",")
# =================================================
# PROCESAMIENTO DE TRAMA RMC
#
# Contiene:
# - Estado GPS
# - Latitud
# - Longitud
# - Velocidad
# - Rumbo
#
# =================================================
if linea.startswith("$GNRMC"):
# Verifica que la trama tenga suficientes datos
if len(datos) > 8:
# La posición es válida
# A = Active
# V = Void
if datos[2] == "A":
estado = "OK"
# -------------------------------------
# VELOCIDAD GPS
# GPS entrega velocidad en nudos
#Conversión:
# km/h = nudos x 1.852
#-------------------------------------
if datos[7] != "":
nudos = float(datos[7])
velocidad = nudos * 1.852
# ---------------------------------
# FILTRO DE VELOCIDAD
# El GPS puede mostrar movimiento
# falso cuando está detenido.
# Si es menor a 2 km/h
# se considera detenido.
# ---------------------------------
if velocidad < 2:
velocidad = 0
# -------------------------------------
# CONVERSIÓN DE COORDENADAS
# -------------------------------------
latitud = convertir_coordenada(
datos[3],
datos[4]
)
longitud = convertir_coordenada(
datos[5],
datos[6]
)
# Rumbo en grados
datos_rumbo = datos[8]
if datos_rumbo != "":
rumbo = datos_rumbo
else:
# GPS tiene señal pero no posición válida
estado = "SIN FIX"
velocidad = 0
# =================================================
# PROCESAMIENTO DE TRAMA GGA
# Contiene:
# - Número de satélites
# - Altitud
#
# =================================================
if linea.startswith("$GNGGA"):
if len(datos) > 9:
# Número de satélites conectados
if datos[7] != "":
satelites = datos[7]
# Altitud sobre nivel del mar
if datos[9] != "":
altitud = datos[9]
except Exception:
# Ignora tramas dañadas
# (el ATGM336H puede mandar líneas mezcladas)
pass
# =====================================================
# MOSTRAR DATOS EN CONSOLA
# Envía todos los datos GPS al monitor serie de Thonny
# para poder revisar el funcionamiento del sistema.
# Se imprime:
# - Estado GPS
# - Velocidad
# - Coordenadas
# - Link Google Maps
# - Altitud
# - Satélites
# - Rumbo
# - Antena
# =====================================================
def mostrar_consola():
print("============================")
print(" DATOS GPS")
print("============================")
print(
"Estado:",
estado
)
print(
"Velocidad:",
round(velocidad,2),
"km/h"
)
print(
"Latitud:",
latitud
)
print(
"Longitud:",
longitud
)
print(
"Google Maps:"
)
print(
"https://maps.google.com/?q={},{}".format(
latitud,
longitud
)
)
print(
"Altitud:",
altitud,
"m"
)
print(
"Satélites:",
satelites
)
print(
"Rumbo:",
rumbo,
"grados"
)
print(
"Antena:",
antena
)
print("============================")
print()
# =====================================================
# CONTROL DE PANTALLA OLED
# Cambia la información mostrada dependiendo
# del valor de la variable "pantalla".
# Pantallas:
# 0 -> Velocidad
# 1 -> Coordenadas
# 2 -> Google Maps
# 3 -> Altitud y rumbo
# 4 -> Señal GPS
# =====================================================
def mostrar_oled():
# Limpia pantalla antes de escribir
oled.fill(0)
# =================================================
# PANTALLA 0
# VELOCIDAD
# =================================================
if pantalla == 0:
oled.text(
"GPS "+estado,
0,
0
)
oled.text(
"VELOCIDAD",
15,
15
)
# Valor grande de velocidad
oled.text(
str(round(velocidad,1)),
35,
32
)
oled.text(
"km/h",
80,
32
)
oled.text(
"SAT:"+str(satelites),
0,
55
)
# =================================================
# PANTALLA 1
# COORDENADAS GPS
# =================================================
elif pantalla == 1:
oled.text(
"POSICION GPS",
0,
0
)
oled.text(
"LAT:",
0,
18
)
oled.text(
str(latitud),
0,
30
)
oled.text(
"LON:",
0,
43
)
oled.text(
str(longitud),
0,
55
)
# =================================================
# PANTALLA 2
# GOOGLE MAPS
# =================================================
elif pantalla == 2:
oled.text(
"GOOGLE MAPS",
0,
0
)
oled.text(
str(latitud),
0,
20
)
oled.text(
str(longitud),
0,
35
)
oled.text(
"q=LAT,LON",
0,
52
)
# =================================================
# PANTALLA 3
# DATOS DE MOVIMIENTO
# =================================================
elif pantalla == 3:
oled.text(
"DATOS GPS",
0,
0
)
oled.text(
"ALT:"+str(altitud)+"m",
0,
25
)
oled.text(
"RUM:"+str(rumbo),
0,
45
)
# =================================================
# PANTALLA 4
# CALIDAD DE SEÑAL
# =================================================
elif pantalla == 4:
oled.text(
"SENAL GPS",
0,
0
)
oled.text(
"SAT:"+str(satelites),
0,
20
)
oled.text(
"ANT:"+antena,
0,
38
)
oled.text(
estado,
0,
55
)
# Envía la información a la pantalla
oled.show()
# =====================================================
# INICIO DEL SISTEMA
# =====================================================
print("==============================")
print(" RP2040 GPS VELOCIMETRO")
print("==============================")
# Muestra inmediatamente la primera pantalla
# (Velocidad)
mostrar_oled()
# =====================================================
# LOOP PRINCIPAL
#
# Este ciclo nunca termina.
#
# Realiza:
#
# 1) Leer GPS
# 2) Actualizar datos
# 3) Cambiar pantallas cada 5 segundos
# 4) Mostrar datos en consola cada 2 segundos
#
# =====================================================
while True:
# =================================================
# LECTURA DEL GPS
# =================================================
if gps.any():
linea = gps.readline()
if linea:
try:
# Convierte bytes recibidos
# a texto
texto = linea.decode().strip()
# Procesa información GPS
procesar_gps(texto)
except:
# Ignora errores de lectura
pass
# =================================================
# CAMBIO AUTOMÁTICO DE PANTALLA
#
# Cada 5 segundos cambia:
#
# Velocidad
# Coordenadas
# Maps
# Datos
# Señal
#
# =================================================
if time.ticks_diff(
time.ticks_ms(),
ultimo_cambio
) > tiempo_pantalla:
pantalla += 1
# Después de pantalla 4
# vuelve a pantalla 0
if pantalla > 4:
pantalla = 0
ultimo_cambio = time.ticks_ms()
# =================================================
# DATOS EN CONSOLA
#
# Cada 2 segundos imprime
# información completa GPS
#
# =================================================
if time.ticks_diff(
time.ticks_ms(),
ultimo_serial
) > tiempo_serial:
mostrar_consola()
ultimo_serial = time.ticks_ms()
# Actualiza pantalla OLED
mostrar_oled()
# Pequeña pausa para estabilidad
time.sleep(0.2)
Con el código cargado en nuestro IDE de Thonny, lo ejecutaremos y tendremos los siguientes resultados.
Resultados
Si ya corriste tú código y estás viendo la pantalla OLED, tendrás la siguiente información:
Velocidad Pantalla 1.
----------------
GPS: OK
0.0
km/h
SAT: 10
----------------Coordenadas Pantalla 2.
----------------
POSICION GPS
LAT:
15.40771
LON:
-95.13196
----------------Google Maps Pantalla 3.
----------------
GOOGLE MAPS
15.40771
-95.13196
maps.google.com
----------------La cadena generada será:
https://maps.google.com/?q=15.40771,-95.13196
Datos de Movimiento Pantalla 4.
----------------
DATOS GPS
ALT:
224 m
RUMBO:
159°
----------------Calidad GPS Pantalla 5.
----------------
SEÑAL GPS
SAT:
12
ANT:
OK
FIX:
SI
----------------Cada pantalla durará 5 segundos, por lo tanto, la secuencia será:
Velocidad
↓
Coordenadas
↓
Maps
↓
Datos
↓
Señal
↓
Velocidad…
De igual forma en la consola de Thonny veremos lo siguiente:
----------------------------
DATOS GPS
----------------------------
Estado GPS: OK
Velocidad: 0.85 km/h
Latitud: 19.40771
Longitud: -99.13196
Google Maps:
https://maps.google.com/?q=19.40771,-99.13196
Altitud: 224 m
Satélites: 12
Rumbo: 159.94 grados
Antena: OK
----------------------------Nota: Al momento de correr el código es normal que aparezca sin señal, ya que tardará 5 minutos aproximadamente en conectarse con los satélites a su alrededor, así que ten paciencia, además hazlo en un lugar abierto, sin tantas paredes, o que este muy cerrado ya que le costará más trabajo conectarse.
Conclusiones
Con este proyecto hemos comprobado que es posible construir un velocímetro GPS completo, compacto y funcional utilizando la tarjeta DualMCU ESP32 + RP2040, el módulo ATGM336H y una pantalla OLED I2C. A lo largo del desarrollo aprendimos a configurar el entorno de trabajo en MicroPython, establecer la comunicación entre los diferentes dispositivos y procesar la información enviada por los satélites para mostrar datos en tiempo real, como la velocidad, las coordenadas geográficas, la altitud y la calidad de la señal.
Uno de los aspectos más interesantes del proyecto es el aprovechamiento de la arquitectura DualMCU, que integra en una sola plataforma las capacidades inalámbricas del ESP32 y la potencia de procesamiento del RP2040. Aunque en esta ocasión el proyecto se centró en el uso del RP2040 para el procesamiento de los datos del GPS, el ESP32 abre la puerta a futuras mejoras, como el envío de información a servidores remotos, la conexión con aplicaciones móviles o la integración con plataformas de Internet de las cosas (IoT).
Ahora cuentas con una base sólida para seguir experimentando y crear tus propios proyectos de geolocalización, aprovechando al máximo las capacidades del ESP32 y el RP2040, todo en una sola tarjeta, la DualMCU.
