Sonificación del eclipse con Arduino, Python, OBS y YouTube Retransmisión en directo
Cómo convertir los datos de una estación Arduino en sonido y retransmitirlos en directo
En este proyecto vamos a construir una pequeña estación científica para el Proyecto Eclipse 2026. Un Arduino Mega recoge temperatura, humedad, luminosidad y radiación UV. Python recibe los datos, los guarda en un CSV, los envía a ThingSpeak y convierte la luminosidad en notas musicales.
Finalmente, OBS Studio recibe ese sonido y lo retransmite en directo a YouTube, mostrando únicamente una imagen del proyecto, sin enseñar nuestro escritorio ni lo que hacemos en el ordenador.
La cadena completa queda así:
Arduino Mega
│
│ USB / COM3
▼
Python
│
├── CSV
├── ThingSpeak
│
└── Sonificación
│
▼
VB-Audio Cable
│
▼
OBS Studio
│
▼
YouTube Live
La estructura y los códigos finales están basados en las pruebas realizadas con el equipo del proyecto.
1. Material necesario
Hardware
- Arduino Mega 2560
- Sensor DHT22
- Sensor de luminosidad
- Sensor UV
- Tarjeta microSD
- Cable USB
- Ordenador Windows
En nuestro caso, esta estación es la ANNIE MAUNDER, dedicada a temperatura, humedad, luz y UV.
2. Código definitivo para Arduino
El Arduino envía una trama sencilla por el puerto serie:
DATOS,temperatura,humedad,luz,uv_adc,uv_voltios
Esto es importante porque Python utiliza exactamente esa estructura para interpretar los datos.
Código Arduino
//====================================================
// ESTACIÓN METEOROLÓGICA IoT
// PROYECTO ECLIPSE 2026
// Arduino Mega 2560
//====================================================
#include <SPI.h>
#include <SD.h>
#include <DHT.h>
//====================================================
// TARJETA SD
//====================================================
#define PIN_SD_CS 53
const char NOMBRE_ARCHIVO[] = "DATOS.CSV";
File archivo;
bool sdOK = false;
//====================================================
// SENSOR DHT22
//====================================================
#define PIN_DHT22 2
#define TIPO_DHT DHT22
DHT dht(PIN_DHT22, TIPO_DHT);
float temperatura = 0.0;
float humedad = 0.0;
bool dhtOK = false;
//====================================================
// TEMPORIZADORES
//====================================================
unsigned long tiempoLectura = 0;
const unsigned long INTERVALO_LECTURA = 2000;
unsigned long tiempoEstado = 0;
const unsigned long INTERVALO_ESTADO = 10000;
//====================================================
// SENSOR DE LUZ
//====================================================
#define PIN_LUZ A0
int luminosidad = 0;
bool luzOK = true;
//====================================================
// SENSOR UV
//====================================================
#define PIN_UV A2
int valorUV = 0;
float tensionUV = 0.0;
bool uvOK = true;
//====================================================
// INICIALIZAR DHT22
//====================================================
void inicializarDHT22()
{
Serial.println();
Serial.println("Inicializando DHT22...");
dht.begin();
delay(1000);
temperatura = dht.readTemperature();
humedad = dht.readHumidity();
if (isnan(temperatura) || isnan(humedad))
{
dhtOK = false;
Serial.println("ERROR DHT22");
}
else
{
dhtOK = true;
Serial.println("DHT22 OK");
}
}
//====================================================
// INICIALIZAR SD
//====================================================
void inicializarSD()
{
Serial.println();
Serial.println("Inicializando tarjeta SD...");
if (!SD.begin(PIN_SD_CS))
{
sdOK = false;
Serial.println("ERROR SD");
return;
}
sdOK = true;
Serial.println("SD OK");
if (!SD.exists(NOMBRE_ARCHIVO))
{
archivo = SD.open(NOMBRE_ARCHIVO, FILE_WRITE);
if (archivo)
{
archivo.println(
"TemperaturaDHT,Humedad,Luminosidad,UV_ADC,UV_Voltios"
);
archivo.close();
Serial.println("Archivo CSV creado.");
}
else
{
Serial.println("ERROR creando CSV");
}
}
else
{
Serial.println("Archivo CSV encontrado.");
}
}
//====================================================
// INICIALIZAR LUZ
//====================================================
void inicializarLuz()
{
Serial.println();
Serial.println("Inicializando sensor de luz...");
pinMode(PIN_LUZ, INPUT);
luzOK = true;
Serial.println("Sensor de luz OK");
}
//====================================================
// INICIALIZAR UV
//====================================================
void inicializarUV()
{
Serial.println();
Serial.println("Inicializando sensor UV...");
pinMode(PIN_UV, INPUT);
valorUV = analogRead(PIN_UV);
tensionUV = valorUV * (5.0 / 1023.0);
uvOK = true;
Serial.println("Sensor UV OK");
Serial.print("Valor inicial : ");
Serial.println(valorUV);
Serial.print("Tension inicial : ");
Serial.print(tensionUV, 8);
Serial.println(" V");
}
//====================================================
// LEER DHT22
//====================================================
void leerDHT22()
{
if (!dhtOK)
return;
temperatura = dht.readTemperature();
humedad = dht.readHumidity();
if (isnan(temperatura) || isnan(humedad))
{
Serial.println("ERROR LEYENDO DHT22");
dhtOK = false;
}
}
//====================================================
// LEER LUZ
//====================================================
void leerLuz()
{
luminosidad = analogRead(PIN_LUZ);
}
//====================================================
// LEER UV
//====================================================
void leerUV()
{
valorUV = analogRead(PIN_UV);
tensionUV = valorUV * (5.0 / 1023.0);
}
//====================================================
// MOSTRAR DATOS
//====================================================
void mostrarDatosSerie()
{
Serial.println();
Serial.println("--------------------------------");
Serial.print("Temperatura : ");
Serial.print(temperatura, 1);
Serial.println(" °C");
Serial.print("Humedad : ");
Serial.print(humedad, 1);
Serial.println(" %");
Serial.print("Luminosidad: ");
Serial.println(luminosidad);
Serial.print("UV (ADC) : ");
Serial.println(valorUV);
Serial.print("UV (Voltios): ");
Serial.print(tensionUV, 8);
Serial.println(" V");
}
//====================================================
// GUARDAR EN SD
//====================================================
void guardarDatosSD()
{
if (!sdOK)
return;
archivo = SD.open(NOMBRE_ARCHIVO, FILE_WRITE);
if (!archivo)
{
Serial.println("ERROR ABRIENDO EL CSV");
return;
}
archivo.print(temperatura, 1);
archivo.print(",");
archivo.print(humedad, 1);
archivo.print(",");
archivo.print(luminosidad);
archivo.print(",");
archivo.print(valorUV);
archivo.print(",");
archivo.println(tensionUV, 8);
archivo.flush();
archivo.close();
}
//====================================================
// ESTADO DEL SISTEMA
//====================================================
void mostrarEstadoSistema()
{
Serial.println();
Serial.println("==========================================");
Serial.println("ESTADO DEL SISTEMA");
Serial.println("==========================================");
Serial.print("Tarjeta SD : ");
Serial.println(sdOK ? "OK" : "ERROR");
Serial.print("DHT22 : ");
Serial.println(dhtOK ? "OK" : "ERROR");
Serial.print("Luz : ");
Serial.println(luzOK ? "OK" : "ERROR");
Serial.print("UV : ");
Serial.println(uvOK ? "OK" : "ERROR");
Serial.println("==========================================");
}
//====================================================
// ENVIAR DATOS A PYTHON
//====================================================
void enviarDatosPython()
{
Serial.print("DATOS,");
Serial.print(temperatura, 1);
Serial.print(",");
Serial.print(humedad, 1);
Serial.print(",");
Serial.print(luminosidad);
Serial.print(",");
Serial.print(valorUV);
Serial.print(",");
Serial.println(tensionUV, 8);
}
//====================================================
// SETUP
//====================================================
void setup()
{
Serial.begin(115200);
delay(2000);
Serial.println();
Serial.println("==========================================");
Serial.println(" ESTACION METEOROLOGICA IoT");
Serial.println(" PROYECTO ECLIPSE 2026");
Serial.println(" Arduino Mega 2560");
Serial.println("==========================================");
inicializarSD();
inicializarDHT22();
inicializarLuz();
inicializarUV();
mostrarEstadoSistema();
}
//====================================================
// LOOP
//====================================================
void loop()
{
if (millis() - tiempoLectura >= INTERVALO_LECTURA)
{
tiempoLectura = millis();
leerDHT22();
leerLuz();
leerUV();
mostrarDatosSerie();
guardarDatosSD();
enviarDatosPython();
}
if (millis() - tiempoEstado >= INTERVALO_ESTADO)
{
tiempoEstado = millis();
mostrarEstadoSistema();
}
}
Esta es la versión definitiva sin el BMP280 para la estación Annie Maunder. La versión anterior todavía contenía las llamadas al BMP280; la corrección final elimina completamente esa parte y deja cinco datos en la trama DATOS.
⚠️ Muy importante
Cuando Python vaya a leer el Arduino:
CIERRA el Monitor Serie del IDE de Arduino.
El puerto COM3 no puede estar siendo utilizado simultáneamente por Arduino IDE y Python. Esto quedó comprobado durante las pruebas.
3. Comprobar el puerto COM
En nuestro caso:
Arduino Mega → COM3
Si Windows asigna otro puerto, hay que cambiarlo también en Python.
No des por hecho que siempre será COM3.
4. Instalar Python
Si no lo tienes instalado:
Descargar Python desde la web oficial
Durante la instalación, marcar:
Add Python to PATH
En nuestro caso utilizamos PyCharm, pero también puedes ejecutar el programa directamente desde Python.
5. Instalar las librerías de Python
En la terminal de PyCharm ejecutamos:
pip install pyserial requests numpy sounddevice
Necesitamos:
pyserial→ comunicación con Arduino.requests→ envío a ThingSpeak.numpy→ generación del sonido.sounddevice→ reproducción del sonido.
6. Instalar el cable de audio virtual
Este paso es el que permite hacer algo muy interesante:
Python genera el sonido → pero en lugar de mandarlo directamente a los altavoces, lo introduce en un cable de audio virtual.
Así OBS puede recogerlo sin utilizar el micrófono del ordenador.
Instalamos:
VB-Audio Virtual Cable — página oficial
Descarga el paquete para Windows, descomprímelo y ejecuta:
VBCABLE_Setup_x64.exe
como administrador.
Después de instalarlo:
🔄 Reinicia Windows.
El propio fabricante indica que hay que reiniciar después de instalar el controlador. (VB-Audio)
7. Comprobar el número del dispositivo de audio
Esto es importante porque el número depende del ordenador.
Creamos:
comprobarnumdispaudio.py
con:
import sounddevice as sd
print("--- LISTA DE DISPOSITIVOS DE AUDIO ---")
devices = sd.query_devices()
for idx, device in enumerate(devices):
if device['max_output_channels'] > 0:
print(
f"ID {idx}: {device['name']} "
f"(Salidas: {device['max_output_channels']})"
)
Lo ejecutamos.
En nuestro ordenador apareció:
ID 7: CABLE Input (VB-Audio Virtual Cable)
Por tanto utilizamos:
DISPOSITIVO_AUDIO_ID = 7
También aparecía otro CABLE Input con ID 16, pero en este equipo utilizaremos el 7.
⚠️ Si haces este proyecto en otro ordenador, no copies el número 7 a ciegas. Ejecuta primero el programa anterior.
8. El programa Python definitivo
Este programa hace tres cosas simultáneamente:
- Guarda los datos en
datos_estacion.csv. - Los manda a ThingSpeak cada 30 segundos.
- Convierte la luminosidad en sonido.
La sonificación utiliza una escala pentatónica y realiza una transición suave entre las notas.
Código
import serial
import time
import requests
import csv
import os
import numpy as np
import sounddevice as sd
from datetime import datetime
# ====================================================
# CONFIGURACIÓN
# ====================================================
PUERTO_SERIE = 'COM3'
BAUDIOS = 115200
NOMBRE_ARCHIVO_CSV = 'datos_estacion.csv'
# ====================================================
# THINGSPEAK
# ====================================================
THINGSPEAK_URL = 'https://api.thingspeak.com/update'
# PON AQUÍ TU PROPIA WRITE API KEY
WRITE_API_KEY = 'TU_WRITE_API_KEY'
INTERVALO_THINGSPEAK = 30
# ====================================================
# AUDIO
# ====================================================
DISPOSITIVO_AUDIO_ID = 7
NOTAS_PENTATONICAS = [
130.81, 146.83, 164.81, 196.00, 220.00,
261.63, 293.66, 329.63, 392.00, 440.00,
523.25, 587.33, 659.25, 783.99, 880.00,
1046.50
]
LUZ_MIN = 0
LUZ_MAX = 1023
VOLUMEN = 0.10
SAMPLE_RATE = 44100
frecuencia_objetivo = NOTAS_PENTATONICAS[0]
frecuencia_actual = NOTAS_PENTATONICAS[0]
fase1 = 0.0
fase2 = 0.0
# ====================================================
# FUNCIONES DE AUDIO
# ====================================================
def callback_audio_calido(outdata, frames, time_info, status):
global frecuencia_objetivo
global frecuencia_actual
global fase1
global fase2
factor_suavizado = 0.04
frecuencias = np.linspace(
frecuencia_actual,
frecuencia_actual +
(frecuencia_objetivo - frecuencia_actual)
* factor_suavizado,
frames
)
frecuencia_actual = frecuencias[-1]
# Fundamental
fases1 = (
fase1 +
2 * np.pi *
np.cumsum(frecuencias) /
SAMPLE_RATE
)
fase1 = fases1[-1] % (2 * np.pi)
onda_base = np.sin(fases1)
# Segundo armónico
fases2 = (
fase2 +
2 * np.pi *
np.cumsum(frecuencias * 2) /
SAMPLE_RATE
)
fase2 = fases2[-1] % (2 * np.pi)
onda_armonico = np.sin(fases2) * 0.25
onda_final = (
onda_base +
onda_armonico
) * VOLUMEN
outdata[:] = onda_final.reshape(-1, 1)
def obtener_nota_musical(valor_luz):
val_clamped = max(
LUZ_MIN,
min(LUZ_MAX, valor_luz)
)
num_notas = len(NOTAS_PENTATONICAS)
indice = int(
(val_clamped / LUZ_MAX)
* (num_notas - 1)
)
return NOTAS_PENTATONICAS[indice]
# ====================================================
# CSV
# ====================================================
if not os.path.exists(NOMBRE_ARCHIVO_CSV):
with open(
NOMBRE_ARCHIVO_CSV,
mode='w',
newline='',
encoding='utf-8'
) as f:
escritor = csv.writer(f)
escritor.writerow([
"Fecha",
"Hora",
"TemperaturaDHT",
"Humedad",
"Luminosidad",
"UV_ADC",
"UV_Voltios"
])
# ====================================================
# CONEXIONES
# ====================================================
try:
arduino = serial.Serial(
PUERTO_SERIE,
BAUDIOS,
timeout=2
)
arduino.setDTR(False)
time.sleep(1)
arduino.flushInput()
arduino.setDTR(True)
print("==============================================")
print(" ESTACIÓN METEOROLÓGICA IoT")
print(" PROYECTO ECLIPSE 2026")
print("==============================================")
print(
f"Conectado con éxito a Arduino en "
f"{PUERTO_SERIE}."
)
# =================================================
# AUDIO → VB-CABLE
# =================================================
stream_audio = sd.OutputStream(
device=DISPOSITIVO_AUDIO_ID,
channels=1,
callback=callback_audio_calido,
samplerate=SAMPLE_RATE
)
stream_audio.start()
print(
f"Sintetizador activo en dispositivo "
f"{DISPOSITIVO_AUDIO_ID}"
)
print("CSV local activo")
print("ThingSpeak activo")
print("Presiona Ctrl + C para salir.")
time.sleep(1)
except Exception as e:
print(
f"Error al inicializar el sistema: {e}"
)
exit()
# ====================================================
# BUCLE PRINCIPAL
# ====================================================
ultimo_envio_ts = 0
try:
while True:
if arduino.in_waiting > 0:
linea_raw = arduino.readline()
if linea_raw:
linea = linea_raw.decode(
'utf-8',
errors='ignore'
).strip()
# ======================================
# DATOS DEL ARDUINO
# ======================================
if linea.startswith("DATOS,"):
partes = linea.split(",")
if len(partes) == 6:
temp_dht = partes[1]
humedad = partes[2]
luz_str = partes[3]
uv_adc = partes[4]
uv_voltios = partes[5]
# =================================
# FECHA Y HORA
# =================================
ahora = datetime.now()
fecha_str = ahora.strftime(
'%Y-%m-%d'
)
hora_str = ahora.strftime(
'%H:%M:%S'
)
# =================================
# SONIFICACIÓN
# =================================
try:
val_luz = int(luz_str)
frecuencia_objetivo = (
obtener_nota_musical(
val_luz
)
)
barras = "█" * int(
(val_luz / LUZ_MAX) * 20
)
print(
f"[{fecha_str} "
f"{hora_str}] | "
f"Luz: {val_luz:4d} | "
f"Nota: "
f"{frecuencia_objetivo:6.1f} Hz "
f"[{barras:<20}]",
end=""
)
except ValueError:
print(
" | Error lectura luz",
end=""
)
# =================================
# CSV
# =================================
with open(
NOMBRE_ARCHIVO_CSV,
mode='a',
newline='',
encoding='utf-8'
) as f:
escritor = csv.writer(f)
escritor.writerow([
fecha_str,
hora_str,
temp_dht,
humedad,
luz_str,
uv_adc,
uv_voltios
])
print(
" | CSV ok",
end=""
)
# =================================
# THINGSPEAK
# =================================
tiempo_actual = time.time()
if (
tiempo_actual -
ultimo_envio_ts
>= INTERVALO_THINGSPEAK
):
ultimo_envio_ts = (
tiempo_actual
)
payload = {
'api_key':
WRITE_API_KEY,
'field1':
temp_dht,
'field2':
humedad,
'field3':
luz_str,
'field4':
uv_adc,
'field5':
uv_voltios
}
try:
respuesta = requests.post(
THINGSPEAK_URL,
data=payload,
timeout=5
)
if (
respuesta.status_code
== 200
and
respuesta.text != '0'
):
print(
f" | ThingSpeak OK "
f"(ID: "
f"{respuesta.text})"
)
else:
print(
f" | Error "
f"ThingSpeak: "
f"{respuesta.text}"
)
except Exception as req_err:
print(
f" | Error red "
f"ThingSpeak: "
f"{req_err}"
)
else:
print("")
except KeyboardInterrupt:
print(
"\n\nDeteniendo el sistema..."
)
stream_audio.stop()
stream_audio.close()
arduino.close()
print(
"Sistema cerrado correctamente."
)
except Exception as e:
print(
f"\nError inesperado: {e}"
)
stream_audio.stop()
stream_audio.close()
arduino.close()
La estructura definitiva conserva la lectura de la trama de seis elementos, el CSV, ThingSpeak y la sonificación.
⚠️ API de ThingSpeak
No publiques nunca tu Write API Key en el blog.
En el código de arriba he puesto:
WRITE_API_KEY = 'TU_WRITE_API_KEY'
Cada usuario debe poner la suya.
La clave se obtiene en:
ThingSpeak → Channels → My Channels → API Keys → Write API Key. (es.mathworks.com)
Y el envío que hacemos desde Python utiliza el endpoint oficial:
https://api.thingspeak.com/update
con field1 a field5. (MathWorks)
Además, los 30 segundos que hemos utilizado son deliberados: ThingSpeak establece para la licencia gratuita un intervalo mínimo de 15 segundos, por lo que 30 segundos funciona perfectamente. (MathWorks)
9. Probar Python antes de abrir OBS
Ejecutamos:
anniecompleto.py
Si todo está correcto veremos algo parecido a:
Conectado con éxito a Arduino en COM3.
Sintetizador activo
CSV local activo
ThingSpeak activo
Y después:
Luz: 523 | Nota: 392.0 Hz
La luminosidad determina la nota musical.
Más luz → notas más agudas.
Menos luz → notas más graves.
10. Instalar OBS Studio
Descargamos OBS desde su página oficial:
OBS es el programa que utilizaremos como codificador y mezclador de la emisión. (obsproject.com)
11. Crear la escena del eclipse
Abrimos OBS.
En Fuentes:
① Añadir imagen
Fuentes
+
↓
Imagen
Seleccionamos nuestro cartel del proyecto.
Por ejemplo:
ECLIPSE 2026
ESTACIÓN ANNIE MAUNDER
SONIFICACIÓN EN DIRECTO
Ajustamos:
Transformar → Ajustar a la pantalla
o:
Ctrl + F
Esto hará que YouTube muestre solo esa imagen.
12. Añadir el sonido del Arduino
En Fuentes:
+
↓
Captura de entrada de audio
Nombre:
Audio Estación
En dispositivo seleccionamos:
CABLE Output
(VB-Audio Virtual Cable)
El funcionamiento del cable es precisamente éste: Python introduce el sonido por CABLE Input y VB-CABLE lo hace aparecer en CABLE Output, que es lo que escucha OBS. (VB-Audio)
13. Comprobar que OBS recibe el sonido
Ejecutamos Python.
En OBS debe empezar a moverse el vúmetro:
Audio Estación
██████████░░░
Si el vúmetro se mueve:
Arduino → Python → VB-Cable → OBS
está funcionando.
En nuestras pruebas también configuramos la monitorización de OBS para poder escuchar el sonido por los altavoces mientras OBS lo envía a la emisión.
14. Una ventaja importante
En Fuentes de OBS solamente debemos tener:
📷 Fondo Eclipse
🔊 Audio Estación
Nada de:
❌ Captura de pantalla
❌ Captura de ventana
❌ Micrófono
De esta forma podemos trabajar tranquilamente con el ordenador mientras la emisión sigue mostrando solo nuestra imagen y el sonido científico generado por la estación.
15. Preparar YouTube Live
Entramos en YouTube y abrimos:
Crear → Emitir en directo
YouTube utiliza su Sala de control en directo para configurar la emisión cuando utilizamos un codificador como OBS. (Ayuda de Google)
Si es la primera vez que vas a emitir, puede ser necesario habilitar previamente las emisiones en directo; YouTube indica que la primera activación puede tardar hasta 24 horas. (Ayuda de Google)
16. Configurar OBS con YouTube
En OBS:
Archivo
↓
Ajustes
↓
Emisión
Seleccionamos:
Servicio: YouTube
La opción más sencilla es:
Conectar cuenta
Seguimos el proceso de autorización de Google.
También podemos utilizar la:
Clave de emisión
YouTube proporciona una clave desde la Sala de control en directo. (Ayuda de Google)
No compartas nunca esa clave.
17. Hacer una prueba privada
Antes de hacer el directo del eclipse recomiendo seleccionar en YouTube:
Privado
o:
Oculto
Así podemos comprobar todo sin que nadie vea la prueba.
YouTube permite seleccionar la privacidad de la emisión. (Ayuda de Google)
18. La secuencia definitiva para el día del eclipse
Aquí está la chuleta que yo tendría preparada:
🔌 1. Conectar Arduino
Arduino Mega → USB → PC
Comprobar:
COM3
💾 2. Comprobar Arduino
Cargar el programa.
Esperar a:
DHT22 OK
SD OK
Sensor de luz OK
Sensor UV OK
❌ 3. Cerrar Arduino IDE / Monitor Serie
Python necesita el COM3.
🎵 4. Ejecutar Python
anniecompleto.py
Debe aparecer:
Conectado con éxito a Arduino en COM3
Sintetizador activo
CSV local activo
ThingSpeak activo
🎚️ 5. Abrir OBS
Comprobar:
Fondo Eclipse
Audio Estación
🔊 6. Comprobar vúmetro
Debe moverse.
▶️ 7. Comenzar emisión
En OBS:
Iniciar transmisión
🌐 8. Comprobar YouTube
En la Sala de control debe aparecer la señal recibida.
YouTube recomienda esperar a que aparezca la vista previa de la señal antes de ponerla definitivamente en directo. (Ayuda de Google)
☀️ ¿Qué tendremos finalmente?
Durante el eclipse, la estación ANNIE MAUNDER estará midiendo:
- 🌡️ Temperatura
- 💧 Humedad
- ☀️ Luminosidad
- 🟣 Radiación UV
Arduino guarda los datos en la tarjeta SD.
Python:
- guarda una copia en CSV;
- manda los datos a ThingSpeak;
- transforma la luminosidad en sonido.
Y OBS convierte todo eso en una emisión:
ECLIPSE
☀️
↓
┌───────────────┐
│ ANNIE MAUNDER │
│ ARDUINO │
└───────┬───────┘
↓
PYTHON
↙ ↓ ↘
CSV SONIDO ThingSpeak
↓
VB-CABLE
↓
OBS
↓
YOUTUBE LIVE
La parte especialmente bonita del proyecto es que no estamos poniendo una música de fondo al eclipse: estamos haciendo que una variable física medida por un sensor controle la música en tiempo real. La luminosidad determina la nota y, por tanto, la evolución del sonido refleja los cambios de iluminación que registra la estación.
🔗 Programas utilizados
⚠️ Una última cosa para el blog
No copies la Write API Key que aparece en tus documentos de trabajo. Al ser una clave de escritura, si esta entrada va a ser pública conviene generar una nueva y utilizar en el código del blog únicamente TU_WRITE_API_KEY. ThingSpeak permite regenerarla si se ha comprometido. (es.mathworks.com)
Etiqueta:AIDARAC, arduino, Arduino Mega, astronomía, ciencia ciudadana, DHT22, eclipse 2026, eclipse solar, estación Annie Maunder, Estación meteorológica, iesmonterroso, obs studio, proyecto eclipse, python, Sensor de luz, Sensor UV, sonificación, sonificación científica, tecnología, ThingSpeak, vb-audio cable, youtube live
También te puede interesar
