Chismes del Lince 166: la Sense HAT, los sentidos de Astro Pi

El Lince de la Noche acababa de montar la placa nueva sobre la Raspberry Pi. La había colocado con la Pi apagada, con los separadores puestos y sin doblar ni un pin. Estaba orgulloso.

—Y ahora —dijo frotándose las patas—, vamos a escribir «HOLA, ISS» en la matriz de LEDs. Que los astronautas sepan que Sierra Bermeja está aquí.

La Gata Montesa ni levantó la vista de la pantalla.

—En la Mission Space Lab la matriz de LEDs está prohibida.

—¿Prohibida? ¡Pero si es lo más bonito que tiene!

—Por eso. Allí arriba hay astronautas trabajando. Nadie quiere sesenta y cuatro lucecitas parpadeando al lado mientras duerme. Nosotros venimos a medir, no a decorar.

El Lince suspiró y ejecutó el programa. En la pantalla apareció la temperatura.

—¡Treinta y dos con ocho grados! —saltó—. ¡El aula está ardiendo! ¡Hay que avisar!

—El aula está a unos veinte —dijo la Gata, señalando el termómetro de la pared—. El que está caliente es el procesador de la Pi, que está justo debajo del sensor.

El Lince miró la placa con desconfianza.

—Entonces, ¿esta placa miente?

—No miente. Mide muy bien lo que tiene al lado. El problema es que lo que tiene al lado no es el aire. Y si queremos que nuestros datos sirvan para algo, tenemos que entender eso antes de mandarlos al espacio.

Introducción

En el Chisme 165 pusimos en marcha la Raspberry Pi del instituto. Hoy le añadimos sus sentidos: la Sense HAT, la placa de sensores de la Astro Pi.

En este chisme vamos a entender qué es la Sense HAT de la Raspberry Pi, qué puede medir y por qué la programamos de una forma muy concreta: la que exige la Mission Space Lab del European Astro Pi Challenge.

Escribiremos nuestro primer programa en Python, leeremos temperatura, humedad, presión y luz, y descubriremos que medir no significa medir bien.

Qué es la Sense HAT

Primero, ¿qué es un HAT?

La Raspberry Pi tiene una fila doble de 40 pines en un borde. Se llaman GPIO (General Purpose Input/Output, entradas y salidas de uso general). Por ahí la Pi puede hablar con otros circuitos.

Un HAT (Hardware Attached on Top, «hardware montado encima») es una placa diseñada para encajar justo encima de esos 40 pines, con el mismo tamaño que la Pi. Es como ponerle un sombrero (hat en inglés): de ahí el nombre.

La Sense HAT

La Sense HAT es un HAT lleno de sensores. Nosotros usamos la versión 2 (V2), que es la misma que llevan las Astro Pi de la Estación Espacial Internacional.

Es decir: lo que medimos aquí abajo lo mide igual allí arriba. Por eso es nuestro banco de pruebas.

Qué lleva dentro

Qué mide o hace	Para qué sirve
Temperatura	Calor del entorno (con trampa, como veremos)
Humedad relativa	Cuánto vapor de agua hay en el aire, en %
Presión	Peso del aire que tenemos encima, en hPa
Acelerómetro	Aceleraciones y hacia dónde está «abajo»
Giroscopio	Giros: cómo de rápido rota la placa
Magnetómetro	Campo magnético (como una brújula)
Sensor de color y luz	Cuánta luz roja, verde, azul y total llega
Matriz de LEDs 8×8	Mostrar dibujos y textos (prohibida en Mission Space Lab)
Joystick	Botón de cinco direcciones

El sensor de color es la gran novedad de la V2. La primera versión no lo tenía.

Cómo habla con la Pi

Todos esos sensores son chips diminutos. La Pi les pregunta y ellos responden por dos de los pines GPIO, usando un protocolo llamado I2C: un mismo par de cables compartido por varios chips, cada uno con su dirección.

No tenemos que preocuparnos por eso: la librería sense_hat de Python hace todo el trabajo. Nosotros solo escribimos sense.get_temperature() y recibimos un número.

Por qué la usamos para Astro Pi

En la Mission Space Lab, los equipos de Bachillerato escriben un programa en Python que se ejecuta durante unos minutos en las Astro Pi de la ISS. Ese programa solo puede medir con lo que tiene la Astro Pi: la Sense HAT y la cámara.

Así que, en la práctica, la Sense HAT Raspberry Pi es nuestro laboratorio en órbita. Cualquier pregunta científica que queramos responder desde el espacio pasa por estos sensores. Por ejemplo:

• ¿Cómo cambia el campo magnético de la Tierra a lo largo de la órbita? (magnetómetro)
• ¿Qué pasa con la luz cuando la ISS pasa del día a la noche? (sensor de color)
• ¿Cómo es el ambiente dentro del módulo donde está la Astro Pi? (temperatura, humedad y presión)

Si no entendemos bien qué mide cada sensor, y qué errores tiene, no sabremos interpretar los datos que vuelvan del espacio.

¿Y la Mission Zero? La Mission Zero de ESO también usa la Sense HAT, pero en un simulador del navegador. No hace falta montar nada.

Por qué la programamos «así»

Nuestro programa podría ser más corto. Pero desde el primer día lo escribimos como si fuera a viajar a la ISS, para coger buenos hábitos. Estas son las normas que ya cumplimos:

• Se llama main.py. Es el nombre que exige la Mission Space Lab.
• El código va en inglés: variables, comentarios y mensajes.
• No usamos la matriz de LEDs. Está prohibida, porque molestaría a la tripulación.
• Las rutas se calculan con Path(__file__).parent, la carpeta donde está el programa. En la ISS no sabemos en qué carpeta se va a ejecutar, así que nunca escribimos rutas a mano. Hoy no guardamos nada, pero dejamos la línea preparada para el próximo chisme.

Qué necesitamos

• La Raspberry Pi 4 B del Chisme 165, funcionando y con acceso por VNC.
• Sense HAT V2, con sus separadores y tornillos.
• Thonny (viene instalado en Raspberry Pi OS).
• Un termómetro de referencia del aula, para comparar.

Montar la Sense HAT

Regla de oro: la Sense HAT se pone y se quita siempre con la Pi apagada y desenchufada.

1. Apaga la Pi (Menú → Apagar), espera a que se apague el LED verde y desenchufa.
2. Atornilla los separadores a la Pi.
3. Coloca la Sense HAT encima de los 40 pines, bien alineada. Presiona por igual en los dos extremos, sin doblar ningún pin.
4. Atornilla la Sense HAT a los separadores.
5. Enchufa la alimentación, lo último.

Al encender, la matriz de LEDs puede mostrar un arcoíris un momento. Es normal: significa que la Pi ha detectado la placa.

[IMAGEN: Sense HAT V2 montada sobre la Raspberry Pi 4 B con los separadores. Alt: Sense HAT Raspberry Pi montada para Astro Pi]

Pasar el programa a la Pi

Para copiar main.py desde el ordenador del aula a la Pi usamos WinSCP, gratuito y gráfico (la versión portable no necesita instalarse):

1. En la Pi, activa SSH: Configuración de Raspberry Pi → Interfaces → SSH.
2. En WinSCP, crea una conexión SFTP con la IP de la Pi, el puerto 22 y el usuario y la contraseña de la Pi.
3. Arrastra la carpeta chisme166-sensehat-basico del panel izquierdo (tu PC) al derecho (la Pi).

¿Por qué no copiar y pegar por VNC? Porque el portapapeles de TigerVNC solo funciona en un sentido: podemos copiar de la Pi al PC (muy útil para llevarnos los resultados), pero no del PC a la Pi. Para eso está WinSCP, que además nos servirá para traer archivos de datos de vuelta.

El código

"""
Chisme 166 - Sense HAT basics
Reads the environmental and colour sensors of the Sense HAT V2.

Rules we already follow (Mission Space Lab):
  - the program is called main.py
  - files are saved next to main.py, using Path(__file__).parent
  - we do NOT use the LED matrix
"""

from pathlib import Path
from time import sleep

from sense_hat import SenseHat

# Folder where this program lives. Everything we save goes here.
base_folder = Path(__file__).parent

sense = SenseHat()

# ---------------------------------------------------------------
# PART 1 - Temperature, humidity and pressure (the important part)
# ---------------------------------------------------------------
# The first pressure reading can be 0 while the sensor wakes up,
# so we read once, wait a little and read again.
sense.get_pressure()
sleep(1)

temperature = sense.get_temperature()   # degrees Celsius
humidity = sense.get_humidity()         # relative humidity, %
pressure = sense.get_pressure()         # hectopascals (hPa)

print("--- Environment ---")
print(f"Temperature: {temperature:.1f} °C")
print(f"Humidity:    {humidity:.1f} %")
print(f"Pressure:    {pressure:.1f} hPa")

# ---------------------------------------------------------------
# PART 2 - Colour and light sensor
# ---------------------------------------------------------------
sense.colour.gain = 60                  # allowed values: 1, 4, 16, 60
sense.colour.integration_cycles = 64    # each cycle lasts 2.4 ms

# Wait so the sensor can take a fresh reading with the new settings
sleep(2 * sense.colour.integration_time)

r, g, b, c = sense.colour.colour        # c = clear: total light, no filter

print("--- Colour sensor ---")
print(f"Gain: {sense.colour.gain}  Integration cycles: {sense.colour.integration_cycles}")
print(f"R={r}  G={g}  B={b}  C={c}")

El programa, línea a línea

Las importaciones. Path sirve para trabajar con rutas de carpetas; sleep hace esperar al programa; SenseHat es la puerta de entrada a todos los sensores.

base_folder = Path(__file__).parent. Guarda la carpeta donde está main.py. Hoy no la usamos, pero en el próximo chisme guardaremos ahí los datos.

sense = SenseHat(). Crea el objeto que representa la placa. A partir de aquí, todo se pide a través de sense.

Parte 1: el ambiente. El sensor de presión puede devolver 0 en la primera lectura, mientras «se despierta». Por eso leemos una vez, esperamos un segundo y leemos de verdad. Después pedimos temperatura (°C), humedad relativa (%) y presión (hPa), y las mostramos con un decimal gracias a :.1f.

Parte 2: el color. Configuramos dos cosas antes de medir:

• La ganancia (gain): cuánto amplifica el sensor la señal. Solo admite 1, 4, 16 o 60. Con poca luz, ganancia alta.
• Los ciclos de integración (integration_cycles): cuánto rato está el sensor «recogiendo» luz. Cada ciclo dura 2,4 ms; con 64 ciclos son unos 154 ms.

Después esperamos el doble del tiempo de integración (sense.colour.integration_time) para asegurarnos de que la lectura es nueva. Por último, sense.colour.colour devuelve cuatro números: R, G, B y C.

Lee y predice

• Si pones la palma de la mano encima de la Sense HAT durante un minuto y vuelves a ejecutar, ¿qué medida cambiará más?
• Si tapas el sensor de color con el dedo, ¿qué valor bajará más: R, G, B o C?
• Si cambias la ganancia de 60 a 1, sin cambiar la luz, ¿los números subirán o bajarán?

Cómo probarlo

1. Abre main.py en Thonny (Archivo → Abrir) y pulsa Run (F5).
2. En el Shell, abajo, deben aparecer dos bloques: Environment y Colour sensor.
3. Apunta la temperatura que da la Sense HAT y la del termómetro del aula.
4. Tapa el sensor de color, vuelve a ejecutar y compara.

Si salen los dos bloques, tu Sense HAT Raspberry Pi está lista para trabajar.

Así salió en nuestra primera prueba, de noche y en interior:

--- Environment ---
Temperature: 32.8 °C
Humidity:    52.0 %
Pressure:    1023.8 hPa
--- Colour sensor ---
Gain: 60  Integration cycles: 64
R=1  G=1  B=1  C=4

Tus números serán distintos, y eso es justo lo interesante: ¿por qué?

[IMAGEN: captura de Thonny con la salida del programa. Alt: primera lectura de la Sense HAT Raspberry Pi en Thonny]

Si aparece un error como OSError o la placa no responde, apaga la Pi y comprueba que la Sense HAT está bien asentada en los pines.

Si TigerVNC deja de actualizar la pantalla, cierra la ventana y vuelve a conectar. Y si lo que quieres es solo ver los datos, no necesitas pantalla: desde una terminal de Windows, ssh usuario@IP_DE_LA_PI y después python3 ~/chisme166-sensehat-basico/main.py.

Qué estamos midiendo realmente

La temperatura: el sensor está demasiado cerca

El sensor de temperatura mide muy bien… la temperatura de la placa. Y la placa está pegada a la Pi, cuyo procesador se calienta mientras trabaja.

Por eso la Sense HAT marca varios grados más que el termómetro del aula. En nuestra prueba marcó 32,8 °C en una habitación donde nadie estaba sudando. No es un fallo del sensor: es que lo que mide no es lo que queremos medir.

Ya nos pasó al calibrar el termómetro de la micro:bit. Un dato no es una medida hasta que sabemos qué error tiene.

La humedad relativa también se contagia

La humedad relativa indica cuánto vapor hay en el aire comparado con el máximo que cabría a esa temperatura. Como el aire caliente admite más vapor, si el sensor está más caliente que el aula, la humedad relativa saldrá más baja de lo real.

Una medida errónea arrastra a otra. Por eso conviene entender cómo se relacionan.

La presión: Estepona frente a Sierra Bermeja

La presión se mide en hectopascales (hPa). A nivel del mar ronda los 1013 hPa, aunque cambia con el tiempo atmosférico: con borrasca baja y con anticiclón sube.

Cuanto más subimos, menos aire tenemos encima y menor es la presión atmosférica. En Estepona, casi a nivel del mar, leeremos valores cerca de esos 1013 hPa. En nuestra prueba salieron 1023,8 hPa: algo por encima de la media, lo que suele indicar anticiclón. En la cumbre de Los Reales, a unos 1450 m, la presión es bastante menor.

Por eso un sensor de presión puede estimar la altitud. Pero como la presión también cambia con el tiempo, esa altitud nunca es exacta. (Este truco lo usaremos en la misión CanSat.)

El color: números sin unidades

• R, G, B: la luz que llega a través de un filtro rojo, uno verde y uno azul.
• C (clear): la luz total, sin filtro.

En nuestra prueba, de noche y con poca luz, salió R=1, G=1, B=1 y C=4: casi nada, aun con la ganancia al máximo. Con tan poca luz, el sensor apenas distingue colores.

Estos números no son lux ni ninguna unidad absoluta. Dependen de la ganancia y del tiempo de integración. Para comparar dos lecturas, las dos tienen que hacerse con la misma configuración.

Para el aula

1. ¿Cuánto se equivoca la temperatura? Tomad la lectura de la Sense HAT y la del termómetro del aula. Calculad la diferencia. ¿Es siempre la misma?
2. ¿Influye el trabajo del procesador? Diseñad una prueba: una lectura con la Pi en reposo y otra con el procesador trabajando (por ejemplo, con un vídeo abierto). ¿Cuántas lecturas necesitáis para estar seguros? ¿Cada cuánto?
3. Ganancia y luz. Con la misma luz, medid con ganancia 1, 4, 16 y 60. Haced una tabla. ¿Los valores crecen en la misma proporción que la ganancia?
4. Una pregunta para la ISS. Elegid un sensor de la Sense HAT y pensad una pregunta científica que solo se pueda responder desde la órbita.

Retos

Reto 1. Haz que funcione

Ejecuta el programa y consigue las cuatro lecturas.

Reto 2. El otro termómetro

La Sense HAT tiene dos sensores que miden temperatura: el de humedad y el de presión. Añade sense.get_temperature_from_pressure() y compara las dos lecturas. ¿Coinciden?

Reto 3. Corrige la temperatura

Con la diferencia que medisteis en «Para el aula», resta una corrección a la temperatura. ¿Sirve siempre o solo en ese momento? ¿Por qué?

Reto 4. Mide el movimiento

Añade sense.get_accelerometer_raw() e imprime los valores x, y, z. Inclina la Pi con cuidado. ¿Qué eje marca la gravedad?

Reto 5. Guarda los datos

Toma una lectura cada 10 segundos durante 5 minutos y guárdalas en un CSV en base_folder, como hicimos con el datalogger de la micro:bit.

Reto 6. Al Replay Tool

Ejecuta tu programa en el Astro Pi Replay Tool. ¿Qué valores devuelve desde la «ISS»?

Es el camino de AIDARAC: sensor → dato → CSV → análisis → conclusión.

Qué hemos aprendido

• La Sense HAT Raspberry Pi es un HAT: una placa que encaja sobre los 40 pines GPIO.
• Es la misma placa que llevan las Astro Pi de la ISS, y es todo lo que tendremos para medir allí arriba (junto con la cámara).
• La programamos desde el principio con las normas de la Mission Space Lab: main.py, código en inglés, rutas con __file__ y sin matriz de LEDs.
• La temperatura sale alta por el calor del procesador, y eso afecta también a la humedad relativa.
• Los valores del sensor de color dependen de la ganancia y del tiempo de integración.

El Lince volvió a mirar el termómetro de la pared y luego la pantalla.

—Vale. Mi placa no miente. Pero tampoco dice toda la verdad.

—Como casi todos los datos —respondió la Gata—. Por eso hay que preguntarles bien.

Para seguir investigando

• Documentación de la librería sense_hat
• Web oficial del European Astro Pi Challenge
• Chisme 165: primeros pasos con la Raspberry Pi 4 B
• Todos los Chismes del Lince

Este chisme es la segunda pieza de la Misión Astro Pi del Lince.