Programa tu Raspberry Pi con Python y Thonny: de la temperatura de la CPU a un gráfico

Tienes una Raspberry Pi recién armada, el escritorio funcionando y la pregunta de siempre: ¿y ahora qué programo? La buena noticia es que no tienes que instalar nada para empezar. Raspberry Pi OS con escritorio ya trae Python y Thonny, un editor pensado para quien escribe su primera línea de código. La placa además tiene un sensor de temperatura dentro del procesador, así que puedes hacer un proyecto real sin conectar ningún componente.

En esta guía vas a escribir un programa que lee la temperatura de la CPU, después una versión que la guarda en un archivo CSV, otra que la muestra en una ventana propia que cambia de color, y al final un gráfico con matplotlib. En el camino vas a entender variables, ciclos, funciones y el depurador, y vas a resolver el error externally-managed-environment que hoy frena a casi todos los que siguen tutoriales antiguos con pip install.

Lo que necesitas

• Una Raspberry Pi con Raspberry Pi OS con escritorio. Cualquier Raspberry Pi 5 sirve (el original usa una de 4 GB); una Raspberry Pi 4 también.
• Una tarjeta microSD con el sistema grabado con Raspberry Pi Imager.
• Una fuente adecuada: para la Pi 5, la oficial de 27 W (5 V, 5 A). Con una fuente más débil la placa limita la corriente de los USB y avisa de bajo voltaje.
• Monitor, teclado y mouse. La Pi 5 tiene salidas micro HDMI, así que necesitas un cable o adaptador a HDMI.

Si tu Pi corre la versión Lite, sin escritorio, no tienes Thonny, pero sí Python: escribes los programas por SSH con el editor nano y los ejecutas con python3 archivo.py. Para aprender, la versión con escritorio es bastante más cómoda.

¿Por qué Python y no otro lenguaje?

Python viene instalado, se lee casi como inglés y prácticamente todos los tutoriales de sensores, cámaras y pines GPIO para la Raspberry Pi lo usan. Las alternativas tienen su lugar, pero para otros objetivos:

Scratch ya no viene en el sistema actual. Si lo quieres, ve al menú de inicio, Preferencias > Recommended Software, sección "Programming", marca "Scratch 3" y presiona "Apply". En esa misma lista verás que Thonny ya está marcado.

Si más adelante quieres programar una Raspberry Pi Pico, lo que aprendas aquí te sirve casi sin cambios: MicroPython es Python adaptado a un microcontrolador.

Python ya está instalado

Abre la terminal (el ícono negro de la barra superior) y escribe python3 --version. En el Raspberry Pi OS de octubre de 2026 responde Python 3.13.5. Acostúmbrate a escribir siempre python3: los tutoriales viejos a veces hablan de Python 2, que ya no existe en el sistema actual y que no necesitas.

Abrir y configurar Thonny

Thonny junta en una sola ventana el editor, un botón para ejecutar y una consola de Python. Lo abres desde la frambuesa del menú, en Programación > Thonny. Al lado verás Geany, un editor para usuarios más avanzados que por ahora puedes ignorar.

La primera vez Thonny abre en modo simple: botones grandes y sin barra de menús. Para esta guía necesitas los ajustes, así que conviene cambiar de inmediato: haz clic en Switch to regular mode, arriba a la derecha, cierra Thonny y ábrelo otra vez. Ahora tienes la barra con File, Edit, View, Run y Tools.

Thonny se mantiene en inglés aunque el sistema esté en español. Los términos que vas a usar: New (el más verde) crea un archivo, Run (flecha verde o F5) ejecuta tu programa, Stop (botón rojo) lo detiene. Arriba está el editor donde escribes, y abajo, la Shell, donde aparecen los resultados y los errores. En la Shell también puedes probar instrucciones sueltas de Python, una por una.

Tu primer programa

Escribe esta línea en el editor:

print("Hallo Raspberry Pi")

Presiona Run. Thonny primero te pide dónde guardar: crea una carpeta nueva llamada meinprojekt en tu carpeta de usuario (el nombre lo usaremos más adelante para el entorno virtual) y guarda el archivo como hallo.py. En la Shell aparece el texto. La función print() muestra lo que pongas entre paréntesis; el texto va entre comillas.

Ejemplo 1: leer la temperatura de la CPU

El primer programa de verdad lee la temperatura del procesador cada dos segundos. No necesitas hardware externo: la librería gpiozero, que viene instalada, sabe leer el sensor interno. Crea un archivo con New, pega el código y guárdalo como cpu_temperature.py:

from time import sleep
from gpiozero import CPUTemperature

cpu = CPUTemperature()

while True:
    temperature = cpu.temperature
    print(f"CPU temperature: {temperature:.1f} °C")
    sleep(2)

Al presionar Run aparece una línea nueva en la Shell cada dos segundos.

Qué significa cada línea

• from ... import ... trae piezas ya hechas a tu programa: sleep para esperar y CPUTemperature para leer el sensor del procesador.
• cpu = CPUTemperature() crea un objeto y lo guarda en la variable cpu. Una variable es un nombre para un valor que vas a necesitar después.
• while True: inicia un ciclo infinito. Todo lo que está indentado debajo se repite hasta que detengas el programa. La indentación de cuatro espacios es obligatoria en Python; Thonny la pone sola después de los dos puntos.
• f"... {temperature:.1f} °C" es un f-string: el valor entre llaves se inserta en el texto, y :.1f lo redondea a un decimal.

De dónde sale ese número

gpiozero no hace magia: lee el archivo /sys/class/thermal/thermal_zone0/temp, donde el kernel de Linux publica la temperatura del chip en milésimas de grado. Puedes comprobarlo en la terminal con cat /sys/class/thermal/thermal_zone0/temp: un valor como 48150 son 48,15 °C. Saber esto te sirve para entender que en Linux casi todo el hardware se lee como si fuera un archivo, y que la librería solo te ahorra el trabajo de abrirlo y convertirlo.

Como referencia: una Pi 5 en reposo con su ventilador oficial suele estar entre 40 y 55 °C. Desde los 80 °C empieza a bajar su frecuencia para protegerse, así que si ves esas cifras sin hacer nada pesado, revisa la ventilación.

Detener el programa

Como el ciclo es infinito, lo detienes con el botón rojo Stop. Thonny muestra en el panel "Assistant" el mensaje KeyboardInterrupt. No es un error de tu código: es la forma en que Python avisa que el programa se interrumpió desde afuera. En la terminal logras lo mismo con Ctrl+C.

Guardar las mediciones en un archivo

Lo que aparece en la Shell se pierde al cerrarla. Esta variante guarda además cada medición con fecha y hora en un archivo CSV, que después puedes abrir en una planilla como LibreOffice Calc (no viene instalado; está en Recommended Software, sección "Office"). Crea otro archivo con New y guárdalo como cpu_temperature_log.py; el primero queda igual:

import csv
from datetime import datetime
from time import sleep
from gpiozero import CPUTemperature

cpu = CPUTemperature()

# "a" appends to the file, so old measurements are kept
with open("cpu_temperature.csv", "a", newline="", encoding="utf-8") as file:
    writer = csv.writer(file)
    while True:
        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        temperature = round(cpu.temperature, 1)
        writer.writerow([now, temperature])
        file.flush()  # write to the file right away
        print(now, temperature)
        sleep(2)

Hay dos novedades. with open(...) abre el archivo y lo cierra bien cuando el programa termina, y el modo "a" agrega al final, así que las mediciones anteriores no se pierden. file.flush() obliga a escribir cada valor en el acto, en lugar de esperar a que el programa termine: si se corta la luz, no pierdes lo medido. El archivo cpu_temperature.csv queda en la misma carpeta del programa.

El depurador: tu programa paso a paso

Cuando un programa no hace lo que esperas, el depurador te muestra qué está pasando por dentro. Ejecuta cpu_temperature.py con el botón Debug (el ícono a la derecha de la flecha verde) en vez de Run. Thonny no corre todo de una vez: espera tus órdenes. Con Step over (F6) avanzas una línea a la vez, y la línea actual queda marcada en amarillo. En View > Variables ves el valor de cada variable en ese momento.

En la captura, temperature vale 47.95 y lo que se imprime después es 48.0. Eso es justo lo que hace :.1f: el valor guardado no cambia, solo se redondea lo que se muestra. Es un buen ejemplo de para qué sirve el depurador: ver el dato real y no lo que el programa te muestra.

Ejemplo 2: una ventana propia con tkinter

Un texto en la Shell sirve, pero una ventana propia se ve como un programa de verdad. Python trae la librería tkinter, también instalada en Raspberry Pi OS. Este programa muestra la temperatura en grande, la actualiza cada dos segundos y la pone en rojo sobre 60 °C. Guárdalo como cpu_temperature_window.py:

import tkinter as tk
from gpiozero import CPUTemperature

cpu = CPUTemperature()

window = tk.Tk()
window.title("CPU temperature")

label = tk.Label(window, font=("Arial", 48), padx=40, pady=20)
label.pack()


def update():
    temperature = cpu.temperature
    label.config(text=f"{temperature:.1f} °C")
    # red above 60 °C, green below
    label.config(fg="red" if temperature > 60 else "green")
    window.after(2000, update)  # run again in 2 seconds


update()
window.mainloop()

Las novedades:

• tk.Tk() crea la ventana, tk.Label un cuadro de texto dentro de ella, y label.pack() lo ubica en la ventana.
• def update(): define una función propia: un bloque de código con nombre que puedes llamar las veces que quieras. Lee la temperatura, la escribe en el cuadro y elige el color con if ... else.
• window.after(2000, update) reemplaza al while True con sleep: la ventana vuelve a llamar a la función después de 2000 milisegundos. Un ciclo infinito con sleep congelaría la ventana, porque tkinter no tendría tiempo de dibujarla. Este patrón (programar la siguiente ejecución en lugar de esperar) es la base de cualquier interfaz gráfica.
• window.mainloop() mantiene la ventana abierta hasta que la cierres.

Para probar el color rojo sin calentar la placa, cambia el 60 del código por 40.

Instalar paquetes extra: el error externally managed environment

Tarde o temprano vas a necesitar una librería que no viene instalada, y muchos tutoriales te dicen que uses pip install. En el Raspberry Pi OS actual ese comando falla con un mensaje de error.

La razón: el sistema administra sus propios paquetes de Python con apt, y si pip los sobrescribiera podría romper programas del sistema que dependen de una versión exacta. Por eso Python bloquea la instalación global (es una regla del estándar PEP 668, que adoptó Debian y por lo tanto Raspberry Pi OS). El mismo mensaje te ofrece dos soluciones, y conviene probarlas en este orden.

Camino 1: instalar el paquete con apt

Muchas librerías conocidas existen como paquete con el prefijo python3-. Para requests:

sudo apt update
sudo apt install python3-requests

Para saber si existe el paquete, usa apt search python3-NOMBRE. Lo que instalas con apt se actualiza junto con el resto del sistema.

Camino 2: un entorno virtual que vea los paquetes del sistema

Si no hay paquete en apt, crea un entorno virtual (venv): una carpeta con su propia instalación de Python donde pip sí está permitido. Lo clave es la opción --system-site-packages: sin ella, el entorno no ve las librerías preinstaladas como gpiozero o picamera2, y tus programas fallan al importarlas.

python3 -m venv --system-site-packages ~/meinprojekt
source ~/meinprojekt/bin/activate
pip install requests

La primera línea crea el entorno en la carpeta meinprojekt que ya usas para tus programas; tus archivos .py no se tocan, solo se agregan las subcarpetas bin, lib e include. La segunda lo activa en la terminal (lo notas porque aparece (meinprojekt) antes del cursor) y la tercera instala el paquete. Para comprobar que todo funciona:

python -c "import gpiozero, requests; print('ok')"

Si la terminal responde ok, tienes disponibles tanto gpiozero del sistema como el paquete nuevo.

Usar el entorno virtual en Thonny

Thonny todavía no sabe que el entorno existe. En modo normal, abre Tools > Options... y ve a la pestaña Interpreter. Deja seleccionado "Local Python 3" y en "Python executable" escribe /home/pi/meinprojekt/bin/python, o búscalo con el botón de los tres puntos. Si tu usuario no se llama pi, cambia ese nombre en la ruta. Al presionar OK, la Shell se reinicia y muestra la ruta nueva, que también aparece abajo a la derecha.

Dos advertencias. En ese mismo cuadro, Thonny ofrece un enlace "New virtual environment": el entorno que crea no ve los paquetes del sistema, y en la prueba del autor original ya import gpiozero falló con ModuleNotFoundError. Crea el entorno en la terminal, como arriba, y en Thonny solo apúntalo. Y no uses la opción --break-system-packages que también menciona el error: instala el paquete en el sistema igual y puede dejar dependencias rotas en la próxima actualización.

Llevar el CSV a un gráfico

El archivo de mediciones se vuelve mucho más útil cuando lo ves como curva. matplotlib existe como paquete de apt, así que lo instalas por el camino 1 con sudo apt install python3-matplotlib. Después, con el registrador funcionando un rato (o detenido), este programa dibuja la temperatura en el tiempo:

import csv
import matplotlib.pyplot as plt

times = []
temps = []
with open("cpu_temperature.csv", newline="", encoding="utf-8") as file:
    for row in csv.reader(file):
        times.append(row[0][11:])  # solo HH:MM:SS
        temps.append(float(row[1]))

plt.plot(times, temps)
plt.xlabel("Hora")
plt.ylabel("Temperatura CPU (°C)")
plt.xticks(times[::max(1, len(times) // 10)], rotation=45)
plt.tight_layout()
plt.show()

Lee cada fila del CSV, separa la hora y la temperatura, y muestra el gráfico en una ventana con solo unas diez etiquetas en el eje horizontal para que no se amontonen. Déjalo midiendo mientras reproduces un video o compilas algo y vas a ver cómo sube la curva y cómo baja cuando el ventilador hace su trabajo.

Que tus programas corran solos

Hasta ahora tus programas viven mientras Thonny esté abierto. En la terminal, entra a la carpeta con cd ~/meinprojekt y ejecuta python3 cpu_temperature.py; si usas el entorno virtual, ~/meinprojekt/bin/python cpu_temperature.py. Para que un programa parta solo en cada encendido, un servicio de systemd o una línea @reboot en el crontab son las formas habituales, y para tareas cada cierto tiempo (una medición por hora, por ejemplo) un cronjob es mejor que un ciclo infinito.

Variantes y mejoras

• Un LED que avisa del calor. Conecta un LED de 5 mm con su resistencia de 220 Ω a un pin GPIO y, con gpiozero.LED, enciéndelo cuando la CPU pase de 60 °C. Es el puente natural hacia controlar hardware con los mismos conceptos de esta guía.
• Medir el ambiente, no solo el chip. Agrega un sensor DHT22 o BME280 y guarda en el mismo CSV la temperatura de la pieza junto a la del procesador. Así ves cuánto influye el calor del verano en la Pi.
• Una alerta a tu celular. Con el paquete requests que instalaste en el camino 1, envía un mensaje a un bot de Telegram cuando la temperatura supere un límite. Es un buen primer contacto con una API web.

Personalización para Chile

En Chile consigues todo lo necesario en MechatronicStore:

• Raspberry Pi 5 2gb Ram (SKU A-403): sobra para Thonny, Python y estos ejemplos. El original usa una de 4 GB, pero aquí no hay diferencia.
• Micro SD tarjeta de memoria 32gb (SKU B-450): para grabar Raspberry Pi OS con escritorio con espacio de sobra.
• Adaptador Micro HDMI (Tipo D) a HDMI Hembra (SKU GV3-2) y Cable HDMI Dorado Macho a Macho 1.8 metros (SKU F-512): para conectar la Pi 5 a tu monitor o televisor.

Si en el tutorial original usan una Raspberry Pi 500 (la que viene dentro del teclado), cualquier Raspberry Pi 5 cumple la misma función con monitor y teclado aparte. La fuente oficial de 27 W para la Pi 5 conviene comprarla original: una fuente genérica de 5 V y 3 A hace que la placa limite la corriente de los USB.

Recursos

• Tutorial original (alemán): Raspberry Pi programmieren mit Python: Einstieg mit Thonny, de Philipp Schweizer en raspberry.tips. Esta versión está basada en él. También hay una versión en inglés.
• Documentación oficial: Python en Raspberry Pi OS, con los dos caminos para instalar paquetes.
• Siguiente paso: GPIO con Python en la Raspberry Pi (en alemán).

Versión chilena con componentes en stock local.