¿Sabías que tu Raspberry Pi Pico puede medir su propia temperatura sin que le conectes ningún sensor externo? El chip RP2040 trae de fábrica un sensor de temperatura escondido, conectado por dentro al conversor analógico a digital. No hay que cablear nada, no hay protoboard, no hay módulos: solo la placa, el cable USB y unas cuantas líneas de MicroPython.

En esta guía vas a aprender a leer ese sensor interno paso a paso. Vamos a partir por entender qué es realmente este sensor y por qué da el número que da, después vas a cargar un programa corto que imprime la temperatura cada segundo en el monitor serial, y al final vas a saber exactamente qué hace cada operación matemática del código, en qué casos te sirve y en cuáles conviene un sensor dedicado. Es un proyecto ideal para partir con la Pico: cero soldadura, resultado inmediato y un concepto (la lectura del ADC) que vas a reutilizar en mil proyectos futuros.

Raspberry Pi Pico midiendo su temperatura interna en MicroPython

Qué es el sensor de temperatura interno del RP2040

El sensor no es un componente aparte pegado en la placa: vive dentro del propio microcontrolador RP2040 y está construido a partir de un diodo polarizado. La idea física es simple: la caída de voltaje de un diodo depende de la temperatura de forma muy predecible. Si mides ese voltaje, puedes despejar la temperatura.

El fabricante caracterizó ese diodo y dejó dos números clave en la hoja de datos del RP2040:

  • A 27 grados Celsius, el sensor entrega típicamente 0,706 volts.
  • La pendiente es de 1,721 milivolts por grado Celsius, y es negativa: a más temperatura, menos voltaje.

Con esos dos datos ya tienes todo lo necesario para convertir un voltaje en grados. Eso sí, conviene ser honesto desde el principio: este sensor no es de precisión. Mide la temperatura del silicio del chip, no la del aire de la pieza, y comparte la referencia de 3,3 V de la placa, que no es un patrón de laboratorio. Para mediciones exactas necesitarías una referencia de voltaje externa estable y calibrar contra un instrumento confiable. Aun así, para monitorear cuánto se calienta tu Pico o para sacarte de un apuro cuando no tienes un sensor a mano, cumple de sobra.

Raspberry Pi Pico con el chip RP2040, que aloja el sensor de temperatura interno

Lo que necesitas (spoiler: casi nada)

La gracia de este proyecto es que el hardware se reduce al mínimo:

  • Una Raspberry Pi Pico o Raspberry Pi Pico W (cualquiera con chip RP2040 sirve, el sensor es el mismo).
  • Un cable USB A a Micro B para conectarla al computador y cargar el código.
  • El editor Thonny (o cualquier IDE con soporte MicroPython) instalado en tu PC.

Eso es todo. No hay sensores externos, ni resistencias, ni protoboard. Si todavía no tienes MicroPython grabado en tu Pico, primero graba el firmware desde el modo BOOTSEL y después vuelve a este tutorial.

El canal ADC4: dónde está conectado el sensor

Acá viene el detalle técnico importante. El RP2040 tiene un conversor analógico a digital (ADC) con varios canales. El sensor de temperatura interno está cableado de fábrica al quinto canal del ADC, el ADC4. Ese canal no sale a ningún pin físico de la placa: es interno y solo lo puedes leer por software.

Entonces, para obtener la temperatura tienes que hacer dos cosas en secuencia: primero leer el valor digital del ADC4, y luego aplicar la fórmula de conversión que transforma ese número en grados. Vamos a ver el código completo y después lo desarmamos línea por línea.

El código completo en MicroPython

Este es el programa entero. Cárgalo en tu Pico con Thonny y ejecútalo: vas a ver la temperatura imprimiéndose en la consola una vez por segundo.

Python 
# GEEK FACTORY - Dale vuelo a tus proyectos
# https://www.geekfactory.mx
#
# Ejemplo para leer el sensor de temperatura interno de un microcontrolador RP2040
# Creamos una función que podemos reutilizar en nuestros proyectos para leer la temperatura
# con el sensor interno.
#
import machine,time
# objeto utilizado para acceder al pin canal analógico del sensor de temperatura interno
tempadc = machine.ADC(4)
# Función para leer sensor de temperatura interno de un microcontrolador RP2040
#
# Esta función lee el sensor de temperatura 10 veces y calcula el promedio de las lecturas,
# retornando un valor mas preciso y libre de ruido.
def tsensor_read_temperature():
    temp = 0
    for i in range(0,10):
        temp += 27 - ((tempadc.read_u16() * (3.3 / 65536)) - 0.706) / 0.001721
        time.sleep_us(100)
    return temp/10
# ciclo principal del programa
while True:
    # llamar a la función para leer el sensor e imprimir a la terminal
    temperature = tsensor_read_temperature()
    print(f"Temperatura leida por sensor interno: {temperature}")
    # esperar un segundo entre lecturas para no saturar la pantalla
    time.sleep(1)

Cómo funciona, paso a paso

El corazón del programa es la función tsensor_read_temperature(). Hace dos cosas: convierte la lectura cruda del ADC en grados y, de paso, promedia varias mediciones para entregar un número más estable y con menos ruido.

Primero se define la función, se crea la variable local temp y se abre un bucle que repite la medición 10 veces:

Python 
def tsensor_read_temperature():
    temp = 0
    for i in range(0,10):

Dentro del bucle pasan solo dos cosas. En la primera línea se toma una lectura y se va sumando a temp en cada vuelta, para después poder promediar. En la segunda se espera 100 microsegundos antes de la siguiente iteración, para que las lecturas no salgan pegadas:

Python 
temp += 27 - ((tempadc.read_u16() * (3.3 / 65536)) - 0.706) / 0.001721
time.sleep_us(100)

Esa primera línea es la más importante de todo el programa, así que vale la pena partirla en dos mitades.

Mitad 1: del valor digital al voltaje. El método read_u16() devuelve la lectura del ADC escalada a 16 bits, o sea un número entre 0 y 65535. Multiplicándolo por 3,3 / 65536 lo conviertes a volts, asumiendo que el rango completo corresponde a los 3,3 V de referencia:

Python 
(tempadc.read_u16() * (3.3 / 65536))

Un matiz que conviene tener claro: el ADC del RP2040 es físicamente de 12 bits, pero MicroPython expone read_u16() con resolución de 16 bits por compatibilidad, escalando el resultado. Por eso el divisor es 65536 (2 elevado a 16) y no 4096. Y como el factor de escala usa los 3,3 V de la placa, cualquier variación en esa alimentación se traslada directo a la medición: ese es el motivo de fondo por el que el sensor no es exacto.

Mitad 2: del voltaje a los grados. Con el voltaje ya calculado, se aplica la caracterización del diodo. Se le resta el voltaje de referencia de 0,706 V (el valor a 27 grados), se divide por la pendiente de 0,001721 V por grado, y ese resultado se le resta a 27, que es la temperatura de referencia:

Python 
27 - ((tempadc.read_u16() * (3.3 / 65536)) - 0.706) / 0.001721

Finalmente, fuera del bucle, se divide la suma acumulada entre 10 para obtener el promedio y la función retorna ese valor. En el bucle principal while True se llama a la función, se imprime el resultado en la terminal y se espera un segundo antes de repetir, para no saturar la consola.

Variantes y mejoras

Una vez que tienes la lectura funcionando, hay varias formas de llevar este proyecto más lejos. Estas ideas no están en el ejemplo original, pero se montan sobre la misma base:

  • Convierte a Fahrenheit o Kelvin. La fórmula te entrega grados Celsius. Si necesitas otra escala, basta una línea extra: fahrenheit = temperature * 9 / 5 + 32. Útil si vas a integrar el dato con sistemas que trabajan en otras unidades.
  • Muéstralo en una pantalla en vez del monitor serial. Conecta un display OLED SSD1306 por I2C y reemplaza el print por una escritura a la pantalla. Así la Pico se vuelve un termómetro autónomo que funciona sin estar conectada al computador.
  • Protege tu placa con un umbral de alarma. Como este sensor mide la temperatura del propio chip, puedes usarlo para vigilancia térmica: si la lectura supera, por ejemplo, 60 grados, enciende un LED o activa un ventilador. Es una forma sencilla de detectar si tu Pico se está sobrecalentando en una carga pesada.
  • Salta a un sensor externo cuando necesites precisión. Si tu objetivo es medir la temperatura del ambiente y no la del silicio, el sensor interno se queda corto. Un DS18B20 o un LM35 te dan lecturas calibradas del entorno. La buena noticia es que la lógica del ADC que aprendiste acá es exactamente la misma que vas a usar con un LM35 analógico.

Personalización para Chile

Lo lindo de este proyecto es que se arma con dos cosas que tienes en stock local en MechatronicStore, sin esperar importaciones:

  • Raspberry Pi Pico (wc 22739) por $7.990 CLP. Trae el chip RP2040 con el sensor de temperatura interno que usamos en todo el tutorial. La versión Pico W es funcionalmente idéntica para esta tarea (mismo RP2040, mismo ADC4).
  • Cable USB a Micro B (wc 37881) por $1.290 CLP. Es el cable que necesitas para alimentar la Pico y cargarle el código desde Thonny.

Cable USB A a Micro B para conectar y programar la Raspberry Pi Pico

Con esos dos productos armas el proyecto completo por menos de $10.000 CLP. Y si más adelante quieres dar el salto a la Pico W para sumarle WiFi y publicar la temperatura en la red, la placa inalámbrica corre este mismo código sin cambiarle una sola línea.

Raspberry Pi Pico W, compatible con el mismo código del sensor interno

Recursos

Versión chilena con componentes en stock local en MechatronicStore. Basado en el tutorial de Geek Factory, reescrito y ampliado con explicación técnica adicional.