Investigación y caracterización técnica de sensores

Antes de integrar múltiples sensores en un sistema centralizado de adquisición de datos, es necesario comprender el comportamiento individual de cada módulo.

En esta actividad, cada grupo trabajará con un único sensor del kit basado en Arduino Mega 2560.

El objetivo no es simplemente “hacerlo funcionar”, sino:

• Comprender qué magnitud física mide.
• Analizar cómo genera la señal.
• Probar su funcionamiento real.
• Documentar técnicamente su comportamiento.
• Proponer su integración futura en RaspiAlarm.

Cada grupo deberá:

• Conectar el sensor al Arduino.
• Desarrollar un programa mínimo funcional.
• Obtener lecturas reales.
• Documentar todo el proceso en un README técnico.
• Entregar código y pruebas.

El resultado final de esta fase será un catálogo técnico de sensores que servirá como base para la arquitectura global del sistema.

2️⃣ PLANTILLA E INSTRUCCIONES PARA EL README

Todos los grupos deben usar la MISMA estructura.

Formato:
Repositorio Git o carpeta con README.md

📄 Plantilla obligatoria

## Sensor: Nombre

### 1. Descripción
...

### 2. Especificaciones técnicas
...

### 3. Conexionado
...

### 4. Código de prueba
...

### 5. Pruebas realizadas
...

### 6. Aplicación en RaspiAlarm
...

📌 Normas importantes

• No copiar documentación sin entenderla.
• Explicar con palabras propias.
• Incluir capturas reales.
• Código comentado línea por línea.
• Usar formato claro y profesional.

Evaluación basada en:

• Rigor técnico
• Claridad
• Funcionamiento real
• Capacidad de integración

📘 3️⃣ LISTA DE SENSORES DEL KIT (Asignación por grupo)

Utilizando exclusivamente material típico de un kit compatible con Arduino Mega 2560.

Lista propuesta:

Grupo 1 – Sensor DHT11 (Temperatura y Humedad)
Grupo 2 – HC-SR04 (Ultrasonidos)
Grupo 3 – Sensor PIR (Movimiento)
Grupo 4 – Sensor de llama
Grupo 5 – Sensor de sonido (KY-038)
Grupo 6 – Sensor LDR (Luz)
Grupo 7 – Sensor de humedad del suelo
Grupo 8 – Sensor de inclinación (Tilt Switch)

Cada grupo solo puede trabajar con su sensor asignado.

📘 4️⃣ Almacenamiento de datos

Arduino Mega 2560 envíe datos por USB y que Windows los guarde automáticamente en el PC.

Nada de herramientas raras. Solo:

• Windows
• IDE de Arduino
• Cable USB
• Python (para capturar y guardar datos)

Arquitectura mental:

Sensor → Arduino → USB (Serial) → PC → Archivo CSV

Eso es adquisición de datos básica. Ciencia aplicada.

En esta práctica vas a convertir tu Raspberry Pi en un pequeño nodo autónomo de captura de datos dentro del proyecto RaspyAlarma.

Tu Raspberry deberá ser capaz de:

1. leer los datos de un sensor con Python,
2. guardar esas lecturas en una base de datos MariaDB,
3. ejecutar ese proceso automáticamente cada cierto tiempo mediante cron,
4. y dejar preparada la información para una futura sincronización con un servidor central.

Todos los alumnos deberán usar la misma estructura de base de datos, ya que más adelante será necesario unificar los datos de todos los sensores y de todas las Raspberry del proyecto.

Objetivo general

El objetivo de esta práctica es crear un sistema automático en el que una Raspberry:

• lea un sensor,
• almacene la lectura en una base de datos local,
• identifique de qué Raspberry procede el dato,
• indique si la lectura representa o no una situación de alerta,
• y marque si ese dato ya fue enviado o no al servidor central.

Estructura obligatoria de la base de datos

Todos los alumnos deberán usar una base de datos llamada exactamente:

raspialarm

Y una tabla llamada exactamente:

lecturas_sensores

Estructura obligatoria de la tabla

La tabla deberá contener estos campos:

• id
• raspberry_id
• nombresensor
• lectura1
• lectura2
• lectura3
• fecha_hora
• alumnoEncargado
• descripcionSensor
• estado_alerta
• enviado_central

Significado de los campos

raspberry_id

Este campo servirá para identificar qué Raspberry ha generado la lectura.

Ejemplos válidos:

• RPI01
• RPI_AULA_01
• RPI_PASILLO
• RPI_HABITACION_3

Este identificador debe ser fijo para cada Raspberry y no debe cambiar entre ejecuciones.

estado_alerta

Este campo servirá para indicar el estado de la lectura.

Valores recomendados:

• normal
• aviso
• critico

No todos los sensores tendrán alertas complejas al principio, pero el campo debe existir ya desde esta fase.

Ejemplo:

• una lectura dentro de lo normal → normal
• una lectura elevada pero no crítica → aviso
• una lectura peligrosa o fuera de umbral → critico

enviado_central

Este campo servirá para saber si esa lectura ya ha sido enviada al servidor central del proyecto.

Valores recomendados:

• 0 → todavía no se ha enviado
• 1 → ya se ha enviado

En esta práctica, normalmente todos los registros nuevos se guardarán inicialmente con valor 0.

Parte 1. Crear la base de datos

Paso 1. Comprobar que MariaDB está activa

Abre una terminal y ejecuta:

sudo systemctl status mariadb

Si no estuviera arrancada:

sudo systemctl start mariadb

Y para dejarla activada al iniciar el sistema:

sudo systemctl enable mariadb

Paso 2. Entrar en MariaDB

sudo mariadb

Paso 3. Crear la base de datos

Dentro de MariaDB:

CREATE DATABASE raspialarm;
SHOW DATABASES;
USE raspialarm;

Parte 2. Crear la tabla común del proyecto

Ejecuta esta instrucción SQL exactamente como aparece:

CREATE TABLE lecturas_sensores (
    id INT AUTO_INCREMENT PRIMARY KEY,
    raspberry_id VARCHAR(50) NOT NULL,
    nombresensor VARCHAR(100) NOT NULL,
    lectura1 DECIMAL(10,2),
    lectura2 DECIMAL(10,2),
    lectura3 DECIMAL(10,2),
    fecha_hora DATETIME NOT NULL,
    alumnoEncargado VARCHAR(100) NOT NULL,
    descripcionSensor VARCHAR(255),
    estado_alerta VARCHAR(20) NOT NULL DEFAULT 'normal',
    enviado_central TINYINT(1) NOT NULL DEFAULT 0
);

Paso 4. Comprobar la estructura de la tabla

DESCRIBE lecturas_sensores;

También puedes verla completa con:

SHOW CREATE TABLE lecturas_sensores;

Parte 3. Crear un usuario específico para la aplicación

No debes usar root dentro del script Python.

Ejecuta:

CREATE USER 'raspiuser'@'localhost' IDENTIFIED BY 'raspi1234';
GRANT ALL PRIVILEGES ON raspialarm.* TO 'raspiuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Parte 4. Crear la estructura de carpetas

Ejecuta:

mkdir -p /home/pi/raspialarma/sensores
mkdir -p /home/pi/raspialarma/logs
mkdir -p /home/pi/raspialarma/docs

Comprueba el resultado:

ls -R /home/pi/raspialarma

Parte 5. Instalar el conector de Python para MariaDB

Ejecuta:

sudo apt update
sudo apt install python3-pip python3-mysqldb -y

Parte 6. Crear primero un script de prueba con datos fijos

Antes de leer el sensor real, primero debes comprobar que:

• Python puede conectarse a MariaDB,
• el INSERT funciona,
• y las nuevas columnas también se guardan correctamente.

Edita el archivo:

nano /home/pi/raspialarma/sensores/captura_sensor.py

Pega este contenido:

#!/usr/bin/env python3

import MySQLdb
from datetime import datetime

def escribir_log(mensaje):
    with open("/home/pi/raspialarma/logs/raspialarma.log", "a") as log:
        log.write(f"{datetime.now()} - {mensaje}\n")

try:
    conexion = MySQLdb.connect(
        host="localhost",
        user="raspiuser",
        passwd="raspi1234",
        db="raspialarm"
    )

    cursor = conexion.cursor()

    raspberry_id = "RPI01"
    nombresensor = "SENSOR_PRUEBA"
    lectura1 = 25.50
    lectura2 = 60.00
    lectura3 = 0.00
    fecha_hora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    alumnoEncargado = "TU_NOMBRE"
    descripcionSensor = "Prueba inicial de inserción en MariaDB"
    estado_alerta = "normal"
    enviado_central = 0

    sql = """
        INSERT INTO lecturas_sensores
        (raspberry_id, nombresensor, lectura1, lectura2, lectura3, fecha_hora,
         alumnoEncargado, descripcionSensor, estado_alerta, enviado_central)
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
    """

    valores = (
        raspberry_id,
        nombresensor,
        lectura1,
        lectura2,
        lectura3,
        fecha_hora,
        alumnoEncargado,
        descripcionSensor,
        estado_alerta,
        enviado_central
    )

    cursor.execute(sql, valores)
    conexion.commit()

    mensaje = "Lectura guardada correctamente."
    print(mensaje)
    escribir_log(mensaje)

except Exception as e:
    error = f"Error: {e}"
    print(error)
    escribir_log(error)

finally:
    try:
        cursor.close()
        conexion.close()
    except:
        pass

El INSERT debe hacerse desde Python

En esta práctica no se insertarán datos desde PHP ni desde formularios web.
La inserción de datos se realizará directamente desde un script Python.

El script debe ejecutarse automáticamente

El script Python deberá ejecutarse cada cierto tiempo utilizando cron.

Debes documentar lo que significa cada lectura

Cada sensor es diferente. Por tanto, deberás dejar claro en tu documentación qué representa:

• lectura1
• lectura2
• lectura3

Por ejemplo, en un DHT11 podrían significar:

• lectura1 = temperatura
• lectura2 = humedad
• lectura3 = no usada

Posible estructura de significado de las lecturas

Para que todos trabajen de forma homogénea, puedes pedirles una tabla como esta en su documentación:

Paso 2. Personalizar el script

Debes modificar al menos estos valores:

raspberry_id = "RPI01"
alumnoEncargado = "TU_NOMBRE"

Sustitúyelos por valores reales.

Ejemplo:

raspberry_id = "RPI_AULA_03"
alumnoEncargado = "Antonio"

Paso 3. Dar permisos de ejecución

chmod +x /home/pi/raspialarma/sensores/captura_sensor.py

Paso 4. Ejecutar el script manualmente

python3 /home/pi/raspialarma/sensores/captura_sensor.py

Si todo ha ido bien, verás:

Lectura guardada correctamente.

Parte 7. Comprobar que el INSERT ha funcionado

Entra en MariaDB:

mariadb -u raspiuser -p

Contraseña:

raspi1234

Dentro de MariaDB:

USE raspialarm;
SELECT * FROM lecturas_sensores;

Comprueba que aparecen correctamente:

• raspberry_id
• estado_alerta
• enviado_central

Parte 8. Sustituir los datos fijos por la lectura real del sensor

Cuando el script de prueba funcione, sustituye los valores fijos por los datos reales del sensor.

La tabla seguirá siendo la misma.
Solo cambiarán los valores que insertas.

Parte 9. Cómo decidir el estado de alerta

Debes programar una lógica sencilla para determinar el valor de estado_alerta.

Ejemplo general

if lectura1 < 30:
    estado_alerta = "normal"
elif lectura1 < 50:
    estado_alerta = "aviso"
else:
    estado_alerta = "critico"

Esto es solo un ejemplo. Cada sensor deberá definir sus propios umbrales.

Ejemplos según sensor

Sensor de temperatura

• temperatura normal → normal
• temperatura alta → aviso
• temperatura muy alta → critico

Sensor de gas

• valor bajo → normal
• valor elevado → aviso
• valor peligroso → critico

Sensor PIR

• sin movimiento → normal
• movimiento detectado → puede mantenerse en aviso o critico, según el criterio del proyecto

Sensor de distancia

• distancia segura → normal
• objeto cercano → aviso
• objeto muy cercano → critico

Parte 10. Valor inicial de enviado_central

Todos los registros nuevos deberán guardarse inicialmente así:

enviado_central = 0

Esto significa que todavía no han sido enviados al servidor central.

Más adelante, cuando construyas el sistema de sincronización, los registros enviados se actualizarán a:

enviado_central = 1

Parte 11. Ejemplo de script con lógica de alerta

#!/usr/bin/env python3

import MySQLdb
from datetime import datetime

def escribir_log(mensaje):
    with open("/home/pi/raspialarma/logs/raspialarma.log", "a") as log:
        log.write(f"{datetime.now()} - {mensaje}\n")

try:
    conexion = MySQLdb.connect(
        host="localhost",
        user="raspiuser",
        passwd="raspi1234",
        db="raspialarm"
    )

    cursor = conexion.cursor()

    raspberry_id = "RPI01"
    nombresensor = "SENSOR_PRUEBA"
    lectura1 = 42.00
    lectura2 = 0.00
    lectura3 = 0.00
    fecha_hora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    alumnoEncargado = "TU_NOMBRE"
    descripcionSensor = "Prueba con niveles de alerta"
    enviado_central = 0

    if lectura1 < 30:
        estado_alerta = "normal"
    elif lectura1 < 50:
        estado_alerta = "aviso"
    else:
        estado_alerta = "critico"

    sql = """
        INSERT INTO lecturas_sensores
        (raspberry_id, nombresensor, lectura1, lectura2, lectura3, fecha_hora,
         alumnoEncargado, descripcionSensor, estado_alerta, enviado_central)
        VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
    """

    valores = (
        raspberry_id,
        nombresensor,
        lectura1,
        lectura2,
        lectura3,
        fecha_hora,
        alumnoEncargado,
        descripcionSensor,
        estado_alerta,
        enviado_central
    )

    cursor.execute(sql, valores)
    conexion.commit()

    mensaje = f"Lectura guardada correctamente con estado {estado_alerta}"
    print(mensaje)
    escribir_log(mensaje)

except Exception as e:
    error = f"Error: {e}"
    print(error)
    escribir_log(error)

finally:
    try:
        cursor.close()
        conexion.close()
    except:
        pass

Parte 12. Automatizar la ejecución con cron

Edita el crontab:

crontab -e

Añade una de estas opciones.

Cada minuto

* * * * * /usr/bin/python3 /home/pi/raspialarma/sensores/captura_sensor.py >> /home/pi/raspialarma/logs/cron.log 2>&1

Cada 5 minutos

*/5 * * * * /usr/bin/python3 /home/pi/raspialarma/sensores/captura_sensor.py >> /home/pi/raspialarma/logs/cron.log 2>&1

Cada 10 minutos

*/10 * * * * /usr/bin/python3 /home/pi/raspialarma/sensores/captura_sensor.py >> /home/pi/raspialarma/logs/cron.log 2>&1

Parte 13. Consultas útiles para revisar la información

Ver todas las lecturas

SELECT * FROM lecturas_sensores;

Ver las últimas lecturas

SELECT * FROM lecturas_sensores ORDER BY fecha_hora DESC;

Ver solo lecturas de una Raspberry

SELECT * FROM lecturas_sensores
WHERE raspberry_id = 'RPI01';

Ver solo lecturas en estado crítico

SELECT * FROM lecturas_sensores
WHERE estado_alerta = 'critico';

Ver solo lecturas pendientes de enviar al servidor central

SELECT * FROM lecturas_sensores
WHERE enviado_central = 0;

Contar cuántas lecturas no se han enviado todavía

SELECT COUNT(*) AS pendientes
FROM lecturas_sensores
WHERE enviado_central = 0;

En la práctica anterior has preparado tu Raspberry Pi para que lea datos de un sensor con Python y los almacene automáticamente en una base de datos MariaDB llamada raspialarm.

Ahora toca construir la siguiente pieza del sistema: un visualizador web en PHP que permita consultar las lecturas almacenadas.

El objetivo es que tu Raspberry no solo capture y guarde información, sino que además pueda mostrarla en una página web accesible desde el navegador.

Este visualizador será la base para futuros paneles más avanzados del proyecto RaspyAlarma, donde más adelante podrás añadir filtros, alertas visuales, gráficas y conexión con un servidor central.

Objetivo de la práctica

En esta práctica vas a crear un pequeño panel web en PHP que:

• se conecte a la base de datos raspialarm,
• lea los registros de la tabla lecturas_sensores,
• muestre los datos en una tabla HTML,
• permita visualizar las lecturas más recientes,
• muestre información útil como el estado de alerta y si el dato fue enviado al servidor central.

Qué vas a construir

Al finalizar la práctica tendrás:

• una carpeta web del proyecto,
• un archivo de conexión a MariaDB,
• una página PHP que recupere datos de la tabla,
• una tabla HTML con todas las lecturas,
• una versión mejorada con formato visual,
• y un pequeño panel base para seguir ampliando en el futuro.

Requisitos previos

Antes de empezar debes tener ya preparado lo siguiente:

• una Raspberry Pi funcionando,
• Apache y PHP instalados,
• MariaDB instalada y operativa,
• la base de datos raspialarm creada,
• la tabla lecturas_sensores creada,
• y varios registros insertados desde el script Python.

Si todavía no tienes registros en la base de datos, primero debes completar la práctica anterior.

Estructura esperada de la base de datos

La práctica parte de esta tabla:

• id
• raspberry_id
• nombresensor
• lectura1
• lectura2
• lectura3
• fecha_hora
• alumnoEncargado
• descripcionSensor
• estado_alerta
• enviado_central

Qué debe hacer el visualizador

El visualizador deberá mostrar como mínimo:

• el identificador del registro,
• el identificador de la Raspberry,
• el nombre del sensor,
• las tres lecturas,
• la fecha y hora,
• el alumno encargado,
• la descripción del sensor,
• el estado de alerta,
• y el estado de envío al servidor central.

Parte 1. Comprobar que Apache, PHP y MariaDB están funcionando

Paso 1. Comprobar Apache

Abre una terminal y ejecuta:

sudo systemctl status apache2

Si no estuviera arrancado:

sudo systemctl start apache2

Y para dejarlo activado al inicio:

sudo systemctl enable apache2

Paso 2. Comprobar MariaDB

sudo systemctl status mariadb

Si no estuviera arrancada:

sudo systemctl start mariadb

Paso 3. Comprobar PHP

Ejecuta:

php -v

Esto debe mostrarte la versión de PHP instalada.

Parte 2. Preparar la carpeta del proyecto web

Tu visualizador web se guardará dentro del directorio servido por Apache.

Paso 1. Ir al directorio web

cd /var/www/html

Paso 2. Crear la carpeta del proyecto

sudo mkdir -p /var/www/html/raspialarma

Paso 3. Cambiar propietario de la carpeta

sudo chown -R $USER:$USER /var/www/html/raspialarma

Paso 4. Entrar en la carpeta

cd /var/www/html/raspialarma

Parte 3. Crear el archivo de conexión a la base de datos

Lo primero que vas a hacer es crear un archivo reutilizable que conecte PHP con MariaDB.

Paso 1. Crear el archivo conexion.php

nano conexion.php

Pega este contenido:

<?php
$host = "localhost";
$usuario = "raspiuser";
$contrasena = "raspi1234";
$basedatos = "raspialarm";

$conexion = new mysqli($host, $usuario, $contrasena, $basedatos);

if ($conexion->connect_error) {
    die("Error de conexión: " . $conexion->connect_error);
}

$conexion->set_charset("utf8");
?>

Guarda el archivo.

Qué hace este archivo

Este archivo:

• define los datos de conexión,
• crea una conexión con MariaDB,
• comprueba si la conexión ha fallado,
• y deja el objeto $conexion listo para usar en otras páginas PHP.

Parte 4. Crear una prueba básica de conexión

Antes de hacer el visualizador completo, conviene comprobar que PHP puede conectarse correctamente a la base de datos.

Paso 1. Crear el archivo prueba_conexion.php

nano prueba_conexion.php

Pega este contenido:

<?php
include("conexion.php");

echo "Conexión con la base de datos realizada correctamente.";

$conexion->close();
?>

Guarda el archivo.

Paso 2. Probar desde el navegador

Abre en el navegador:

http://IP_DE_LA_RASPBERRY/raspialarma/prueba_conexion.php

Si todo ha ido bien, deberías ver:

Conexión con la base de datos realizada correctamente.

Parte 5. Crear la primera página que lea datos de la tabla

Ahora vas a crear una página PHP que recupere registros de lecturas_sensores.

Paso 1. Crear el archivo ver_lecturas.php

nano ver_lecturas.php

Pega este contenido:

<?php
include("conexion.php");

$sql = "SELECT * FROM lecturas_sensores ORDER BY fecha_hora DESC";
$resultado = $conexion->query($sql);

if ($resultado->num_rows > 0) {
    while ($fila = $resultado->fetch_assoc()) {
        echo "ID: " . $fila["id"] . "<br>";
        echo "Raspberry: " . $fila["raspberry_id"] . "<br>";
        echo "Sensor: " . $fila["nombresensor"] . "<br>";
        echo "Lectura 1: " . $fila["lectura1"] . "<br>";
        echo "Lectura 2: " . $fila["lectura2"] . "<br>";
        echo "Lectura 3: " . $fila["lectura3"] . "<br>";
        echo "Fecha y hora: " . $fila["fecha_hora"] . "<br>";
        echo "Alumno: " . $fila["alumnoEncargado"] . "<br>";
        echo "Descripción: " . $fila["descripcionSensor"] . "<br>";
        echo "Estado alerta: " . $fila["estado_alerta"] . "<br>";
        echo "Enviado central: " . $fila["enviado_central"] . "<br>";
        echo "<hr>";
    }
} else {
    echo "No hay registros en la base de datos.";
}

$conexion->close();
?>

Guarda el archivo.

Paso 2. Probar desde el navegador

Abre:

http://IP_DE_LA_RASPBERRY/raspialarma/ver_lecturas.php

Si tienes datos en la base, deberían mostrarse uno debajo de otro.

Parte 6. Transformar la salida en una tabla HTML

La salida anterior funciona, pero no es cómoda de leer.
Ahora vas a mostrar los datos en una tabla HTML.

Paso 1. Sustituir el contenido de ver_lecturas.php

Edita el archivo:

nano ver_lecturas.php

Y reemplázalo por este contenido:

<?php
include("conexion.php");

$sql = "SELECT * FROM lecturas_sensores ORDER BY fecha_hora DESC";
$resultado = $conexion->query($sql);
?>

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Lecturas RaspyAlarma</title>
</head>
<body>

<h1>Lecturas almacenadas en RaspyAlarma</h1>

<?php
if ($resultado->num_rows > 0) {
    echo "<table border='1' cellpadding='5' cellspacing='0'>";
    echo "<tr>
            <th>ID</th>
            <th>Raspberry</th>
            <th>Sensor</th>
            <th>Lectura 1</th>
            <th>Lectura 2</th>
            <th>Lectura 3</th>
            <th>Fecha y hora</th>
            <th>Alumno</th>
            <th>Descripción</th>
            <th>Estado alerta</th>
            <th>Enviado central</th>
          </tr>";

    while ($fila = $resultado->fetch_assoc()) {
        echo "<tr>";
        echo "<td>" . $fila["id"] . "</td>";
        echo "<td>" . $fila["raspberry_id"] . "</td>";
        echo "<td>" . $fila["nombresensor"] . "</td>";
        echo "<td>" . $fila["lectura1"] . "</td>";
        echo "<td>" . $fila["lectura2"] . "</td>";
        echo "<td>" . $fila["lectura3"] . "</td>";
        echo "<td>" . $fila["fecha_hora"] . "</td>";
        echo "<td>" . $fila["alumnoEncargado"] . "</td>";
        echo "<td>" . $fila["descripcionSensor"] . "</td>";
        echo "<td>" . $fila["estado_alerta"] . "</td>";
        echo "<td>" . $fila["enviado_central"] . "</td>";
        echo "</tr>";
    }

    echo "</table>";
} else {
    echo "<p>No hay registros en la base de datos.</p>";
}

$conexion->close();
?>

</body>
</html>

Guarda el archivo.

Paso 2. Ver el resultado en el navegador

Recarga:

http://IP_DE_LA_RASPBERRY/raspialarma/ver_lecturas.php

Ahora los datos deberían verse en forma de tabla.

Parte 7. Mejorar la visualización del estado de alerta y del envío central

Mostrar 0 y 1 no es muy visual.
Vas a convertir esos valores en texto más claro.

Paso 1. Modificar la parte del while

Dentro del while, antes de imprimir la fila, añade esta lógica:

$enviado = ($fila["enviado_central"] == 1) ? "Sí" : "No";

Y en lugar de imprimir directamente enviado_central, muestra $enviado.

Además, puedes mejorar el campo estado_alerta manteniéndolo como texto.

La parte completa quedaría así:

while ($fila = $resultado->fetch_assoc()) {
    $enviado = ($fila["enviado_central"] == 1) ? "Sí" : "No";

    echo "<tr>";
    echo "<td>" . $fila["id"] . "</td>";
    echo "<td>" . $fila["raspberry_id"] . "</td>";
    echo "<td>" . $fila["nombresensor"] . "</td>";
    echo "<td>" . $fila["lectura1"] . "</td>";
    echo "<td>" . $fila["lectura2"] . "</td>";
    echo "<td>" . $fila["lectura3"] . "</td>";
    echo "<td>" . $fila["fecha_hora"] . "</td>";
    echo "<td>" . $fila["alumnoEncargado"] . "</td>";
    echo "<td>" . $fila["descripcionSensor"] . "</td>";
    echo "<td>" . $fila["estado_alerta"] . "</td>";
    echo "<td>" . $enviado . "</td>";
    echo "</tr>";
}

Parte 8. Añadir estilo visual básico con CSS

Ahora vas a mejorar un poco la apariencia de la página.

Paso 1. Añadir estilos dentro del <head>

Sustituye el <head> por este:

<head>
    <meta charset="UTF-8">
    <title>Lecturas RaspyAlarma</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f6f8;
            margin: 20px;
        }

        h1 {
            color: #1f3c88;
        }

        table {
            width: 100%;
            border-collapse: collapse;
            background: white;
        }

        th {
            background-color: #1f3c88;
            color: white;
            padding: 10px;
        }

        td {
            padding: 8px;
            border: 1px solid #ccc;
            text-align: center;
        }

        tr:nth-child(even) {
            background-color: #f2f2f2;
        }
    </style>
</head>

Guarda y recarga la página.

Parte 9. Colorear visualmente el estado de alerta

Ahora vas a resaltar el estado de alerta.

Paso 1. Añadir una variable para el color

Dentro del while, añade esta lógica:

$enviado = ($fila["enviado_central"] == 1) ? "Sí" : "No";

$colorAlerta = "black";

if ($fila["estado_alerta"] == "normal") {
    $colorAlerta = "green";
} elseif ($fila["estado_alerta"] == "aviso") {
    $colorAlerta = "orange";
} elseif ($fila["estado_alerta"] == "critico") {
    $colorAlerta = "red";
}

Paso 2. Mostrar el estado con color

Sustituye la celda de estado_alerta por esta:

echo "<td style='color:$colorAlerta; font-weight:bold;'>" . $fila["estado_alerta"] . "</td>";

Esto hará que:

• normal aparezca en verde,
• aviso en naranja,
• critico en rojo.

Parte 10. Crear una versión que muestre solo las últimas lecturas

A veces no interesa ver todo, sino solo las más recientes.

Paso 1. Crear el archivo ultimas_lecturas.php

nano ultimas_lecturas.php

Pega este contenido:

<?php
include("conexion.php");

$sql = "SELECT * FROM lecturas_sensores ORDER BY fecha_hora DESC LIMIT 10";
$resultado = $conexion->query($sql);
?>

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Últimas lecturas</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f6f8;
            margin: 20px;
        }

        h1 {
            color: #1f3c88;
        }

        table {
            width: 100%;
            border-collapse: collapse;
            background: white;
        }

        th {
            background-color: #1f3c88;
            color: white;
            padding: 10px;
        }

        td {
            padding: 8px;
            border: 1px solid #ccc;
            text-align: center;
        }

        tr:nth-child(even) {
            background-color: #f2f2f2;
        }
    </style>
</head>
<body>

<h1>Últimas 10 lecturas registradas</h1>

<?php
if ($resultado->num_rows > 0) {
    echo "<table>";
    echo "<tr>
            <th>ID</th>
            <th>Raspberry</th>
            <th>Sensor</th>
            <th>Lectura 1</th>
            <th>Lectura 2</th>
            <th>Lectura 3</th>
            <th>Fecha y hora</th>
            <th>Estado alerta</th>
          </tr>";

    while ($fila = $resultado->fetch_assoc()) {
        $colorAlerta = "black";

        if ($fila["estado_alerta"] == "normal") {
            $colorAlerta = "green";
        } elseif ($fila["estado_alerta"] == "aviso") {
            $colorAlerta = "orange";
        } elseif ($fila["estado_alerta"] == "critico") {
            $colorAlerta = "red";
        }

        echo "<tr>";
        echo "<td>" . $fila["id"] . "</td>";
        echo "<td>" . $fila["raspberry_id"] . "</td>";
        echo "<td>" . $fila["nombresensor"] . "</td>";
        echo "<td>" . $fila["lectura1"] . "</td>";
        echo "<td>" . $fila["lectura2"] . "</td>";
        echo "<td>" . $fila["lectura3"] . "</td>";
        echo "<td>" . $fila["fecha_hora"] . "</td>";
        echo "<td style='color:$colorAlerta; font-weight:bold;'>" . $fila["estado_alerta"] . "</td>";
        echo "</tr>";
    }

    echo "</table>";
} else {
    echo "<p>No hay lecturas disponibles.</p>";
}

$conexion->close();
?>

</body>
</html>

Guarda y prueba en el navegador.

Parte 11. Crear una página con resumen rápido

Ahora vas a crear una página que muestre algunos datos resumidos:

• número total de registros,
• número de alertas críticas,
• número de registros pendientes de enviar.

Paso 1. Crear el archivo resumen.php

nano resumen.php

Pega este contenido:

<?php
include("conexion.php");

$sqlTotal = "SELECT COUNT(*) AS total FROM lecturas_sensores";
$sqlCriticos = "SELECT COUNT(*) AS criticos FROM lecturas_sensores WHERE estado_alerta = 'critico'";
$sqlPendientes = "SELECT COUNT(*) AS pendientes FROM lecturas_sensores WHERE enviado_central = 0";

$total = $conexion->query($sqlTotal)->fetch_assoc()["total"];
$criticos = $conexion->query($sqlCriticos)->fetch_assoc()["criticos"];
$pendientes = $conexion->query($sqlPendientes)->fetch_assoc()["pendientes"];
?>

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Resumen RaspyAlarma</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background-color: #f4f6f8;
            margin: 20px;
        }

        h1 {
            color: #1f3c88;
        }

        .caja {
            background: white;
            border: 1px solid #ccc;
            padding: 20px;
            margin-bottom: 15px;
            font-size: 20px;
        }
    </style>
</head>
<body>

<h1>Resumen del sistema RaspyAlarma</h1>

<div class="caja">Total de registros: <?php echo $total; ?></div>
<div class="caja">Alertas críticas: <?php echo $criticos; ?></div>
<div class="caja">Pendientes de enviar al servidor central: <?php echo $pendientes; ?></div>

</body>
</html>

Guarda y pruébalo en el navegador.

Parte 12. Qué debe comprobar el alumno

Debes verificar que:

• PHP conecta con la base de datos,
• la consulta SQL recupera datos,
• la tabla HTML se genera correctamente,
• los campos se muestran completos,
• el estado de alerta aparece bien,
• el campo enviado_central se interpreta correctamente,
• y las páginas son accesibles desde el navegador.

Parte 13. Errores frecuentes

Error 1. Página en blanco

Suele ocurrir por:

• un error de sintaxis en PHP,
• una etiqueta mal cerrada,
• o un problema en la conexión.

Error 2. Error de conexión a la base de datos

Comprueba:

• usuario,
• contraseña,
• nombre de la base,
• y que MariaDB esté arrancada.

Error 3. No aparecen datos

Comprueba:

• que existan registros en lecturas_sensores,
• que el SELECT esté bien escrito,
• y que el script Python haya insertado correctamente.

Error 4. Apache no muestra la página

Comprueba:

• que Apache esté arrancado,
• que el archivo esté en /var/www/html/raspialarma,
• y que la URL sea correcta.

Parte 14. Orden recomendado de trabajo

Debes seguir este orden:

Fase 1

Crear conexion.php.

Fase 2

Probar la conexión con prueba_conexion.php.

Fase 3

Crear ver_lecturas.php con salida simple.

Fase 4

Transformar la salida en tabla HTML.

Fase 5

Añadir estilos CSS.

Fase 6

Resaltar el estado de alerta y el envío central.

Fase 7

Crear páginas adicionales como ultimas_lecturas.php y resumen.php.

Parte 15. Qué debes entregar

La práctica deberá incluir:

• archivo conexion.php,
• archivo prueba_conexion.php,
• archivo ver_lecturas.php,
• archivo ultimas_lecturas.php,
• archivo resumen.php,
• capturas de funcionamiento en el navegador,
• explicación de qué muestra cada página,
• y evidencia de que los datos provienen realmente de MariaDB.

Parte 16. Resultado esperado

Al finalizar la práctica deberás tener un pequeño sistema web local capaz de consultar y mostrar los datos recogidos por tu Raspberry.

Tu Raspberry ya no solo capturará y almacenará datos, sino que además ofrecerá un primer panel web para visualizarlos.

Ese será el punto de partida para futuras mejoras como:

• filtros por sensor,
• búsquedas por Raspberry,
• páginas de alertas,
• gráficas,
• exportación de datos,
• y sincronización con el servidor central.

Resumen rápido de archivos

conexion.php

Se encarga de conectar PHP con MariaDB.

prueba_conexion.php

Comprueba que la conexión funciona.

ver_lecturas.php

Muestra todos los registros de la tabla.

ultimas_lecturas.php

Muestra solo las últimas lecturas.

resumen.php

Muestra indicadores rápidos del sistema.

🎧 Resumen en audio del tema
Escucha este breve audio para repasar las ideas principales de la tarea antes de continuar o al finalizar la lectura.

Introducción

Hasta este momento, varias Raspberry Pi del proyecto RaspyAlarma ya son capaces de leer información de sensores y almacenarla en una base de datos local. Ese primer paso permite que cada nodo funcione de manera autónoma y conserve sus propias lecturas.

Ahora vamos a dar el siguiente salto: construir un servidor central que reciba los datos generados por todas las Raspberry y los almacene en una base de datos general. A partir de esa información centralizada, desarrollaremos también una interfaz web que permita consultar el estado de todos los sensores, visualizar gráficas, detectar alertas y disponer de un histórico común.

Aunque en un sistema real normalmente existiría un único servidor central, en esta práctica se permitirá que el alumnado trabaje de forma flexible: pueden hacerlo individualmente o en grupos, e incluso pueden desplegar más de un servidor central para repartir tareas y favorecer la participación.

Reto del proyecto

Debéis construir el servidor central del sistema RaspyAlarma. Este servidor se ejecutará en una máquina virtual Ubuntu alojada en Proxmox y será el encargado de recibir, almacenar y mostrar las lecturas de sensores enviadas por distintas Raspberry Pi.

Cada Raspberry seguirá guardando sus datos en local, pero además tendrá que sincronizar los registros pendientes con la base de datos central. A partir de esta información, deberéis desarrollar una interfaz web que permita visualizar el estado de todos los sensores, consultar históricos y representar gráficas.

El objetivo no es solo almacenar datos, sino crear una arquitectura distribuida funcional, organizada y ampliable, similar a la que podría utilizarse en un entorno profesional real.

Objetivos del proyecto

Al finalizar esta práctica, el alumnado deberá ser capaz de:

• Desplegar una máquina virtual Ubuntu en Proxmox que actuará como servidor central.
• Instalar y configurar en ella los servicios necesarios.
• Diseñar una base de datos central para almacenar las lecturas de todas las Raspberry.
• Implementar un mecanismo para recibir datos desde los nodos remotos.
• Guardar las lecturas recibidas en una base de datos general.
• Crear una interfaz web para visualizar la información agregada.
• Mostrar listados, filtros, estados de alerta y gráficas.
• Comprender la diferencia entre almacenamiento local en nodos y centralización de información.
• Simular una arquitectura real de monitorización distribuida.

Escenario de trabajo

Imaginad que habéis diseñado un sistema de asistencia y monitorización distribuido. Cada Raspberry Pi recoge lecturas de sensores instalados en distintos puntos y almacena esos datos localmente. Sin embargo, eso no es suficiente para gestionar el sistema completo.

Necesitamos un centro de control, una máquina central capaz de:

• Recibir información desde todas las Raspberry.
• Unificar los datos en una sola base de datos.
• Mostrar el estado general del sistema.
• Generar paneles visuales con tablas y gráficas.
• Identificar situaciones de alerta.
• Servir como base para futuras ampliaciones, como envío de correos, paneles de incidencias o integración con otros sistemas.

Arquitectura propuesta

La arquitectura recomendada para esta práctica será la siguiente:

Nodo Raspberry Pi

Cada Raspberry:

• Lee sensores localmente.
• Guarda sus lecturas en su propia base de datos.
• Identifica qué registros todavía no han sido enviados al servidor central.
• Envía únicamente esos registros pendientes.
• Marca los registros como enviados cuando el servidor central los confirma.

Servidor central Ubuntu

La máquina virtual Ubuntu:

• Ejecuta Apache o Nginx.
• Ejecuta PHP para la parte web y la recepción de datos.
• Ejecuta MariaDB o MySQL para almacenar todas las lecturas.
• Expone una ruta o endpoint para recibir los datos enviados por las Raspberry.
• Ofrece un panel web para visualizar y analizar la información.

Idea importante de diseño

Aunque técnicamente se podría hacer que el servidor central se conecte a las bases de datos de las Raspberry y “tire” de los datos, no es la opción recomendada para esta práctica.

La mejor solución didáctica y técnica es esta:

• La Raspberry guarda sus lecturas en local.
• La Raspberry envía periódicamente los registros pendientes al servidor central.
• El servidor central responde confirmando la recepción.
• La Raspberry marca esos registros como enviados.

Este enfoque tiene varias ventajas:

• Es más realista.
• Es más seguro.
• Evita abrir las bases de datos de las Raspberry al exterior.
• Reduce problemas de conectividad.
• Permite trabajar con sincronización parcial y tolerancia a fallos.

Requisitos de la práctica

El sistema deberá cumplir, como mínimo, con los siguientes requisitos.

En el servidor central

• Máquina virtual Ubuntu funcionando en Proxmox.
• IP fija o localizable dentro de la red.
• Apache + PHP + MariaDB instalados.
• Base de datos central creada.
• Endpoint de recepción de datos funcionando.
• Interfaz web operativa.

En las Raspberry

• Base de datos local con lecturas ya almacenadas.
• Script de sincronización hacia el servidor central.
• Uso de un identificador único de Raspberry.
• Campo que indique si el registro ya fue enviado.
• Capacidad para reenviar registros pendientes si hubo error.

Tecnologías recomendadas

Para esta práctica se recomienda utilizar:

• Proxmox para alojar la máquina virtual.
• Ubuntu Server como sistema operativo del servidor central.
• Apache como servidor web.
• PHP para el desarrollo del endpoint y del panel web.
• MariaDB/MySQL como sistema gestor de base de datos.
• Python en las Raspberry para el envío de datos.
• Cron para automatizar los envíos periódicos.
• Chart.js para representar gráficas en la interfaz web.

Parte 1 – Creación del servidor central

Paso 1. Crear la máquina virtual en Proxmox

Cada grupo o alumno deberá crear una máquina virtual Ubuntu en Proxmox que actuará como servidor central.

Características recomendadas

• 2 vCPU
• 2 GB o 4 GB de RAM
• 20 GB de disco
• Ubuntu Server
• Adaptador de red en la misma red que las Raspberry

Tareas

• Crear la VM.
• Instalar Ubuntu Server.
• Configurar nombre del equipo.
• Configurar acceso por usuario y contraseña.
• Anotar la IP asignada.

Recomendación

Es buena idea asignar una IP fija o una reserva DHCP, para que las Raspberry sepan siempre a qué dirección enviar los datos.

Paso 2. Actualizar el sistema

Una vez instalada la VM, actualizad el sistema:

sudo apt update && sudo apt upgrade -y

Paso 3. Instalar los paquetes necesarios

Instalad los componentes del servidor central:

sudo apt install apache2 mariadb-server php libapache2-mod-php php-mysql php-json php-mbstring -y

Comprobad que Apache está funcionando:

sudo systemctl status apache2

Comprobad también MariaDB:

sudo systemctl status mariadb

Paso 4. Preparar la base de datos central

Acceded a MariaDB:

sudo mysql

Cread la base de datos general del proyecto. Por ejemplo:

CREATE DATABASE raspialarma_central;

Después, cread un usuario específico para la aplicación:

CREATE USER 'raspyadmin'@'localhost' IDENTIFIED BY 'TuPasswordSegura';
GRANT ALL PRIVILEGES ON raspialarma_central.* TO 'raspyadmin'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Parte 2 – Diseño de la base de datos central

Paso 5. Crear la tabla principal de lecturas

La tabla central debe recoger información común de todas las Raspberry y de todos los sensores.

Estructura recomendada

USE raspialarma_central;CREATE TABLE lecturas_centrales (
    id INT AUTO_INCREMENT PRIMARY KEY,
    id_raspberry VARCHAR(100) NOT NULL,
    nombresensor VARCHAR(100) NOT NULL,
    lectura1 VARCHAR(100),
    lectura2 VARCHAR(100),
    lectura3 VARCHAR(100),
    fecha_hora DATETIME NOT NULL,
    alumnoEncargado VARCHAR(100),
    descripcionSensor TEXT,
    estado_alerta VARCHAR(50) DEFAULT 'normal',
    fecha_recepcion TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    origen_ip VARCHAR(100),
    hash_registro VARCHAR(255),
    UNIQUE KEY unique_registro (id_raspberry, nombresensor, fecha_hora, hash_registro)
);

Explicación de algunos campos importantes

id_raspberry

Identifica de forma única de qué Raspberry procede el dato.

estado_alerta

Permite saber si la lectura está en estado normal, aviso o alerta.

fecha_recepcion

Indica cuándo llegó el registro al servidor central.

origen_ip

Puede almacenar la IP desde la que se envió el dato.

hash_registro

Sirve para evitar duplicados si una Raspberry vuelve a mandar el mismo dato.

Mejora interesante

También podéis crear una tabla de nodos Raspberry:

CREATE TABLE raspberries (
    id INT AUTO_INCREMENT PRIMARY KEY,
    id_raspberry VARCHAR(100) UNIQUE NOT NULL,
    nombre VARCHAR(100),
    ubicacion VARCHAR(100),
    descripcion TEXT,
    ultima_conexion DATETIME,
    estado VARCHAR(50) DEFAULT 'activo'
);

Esto os permitirá saber qué nodos existen, cuál fue su última conexión y tener una visión más ordenada del sistema.

Parte 3 – Recepción de datos en el servidor central

Paso 6. Crear el endpoint de recepción

En el servidor Ubuntu, cread una carpeta para vuestra aplicación:

sudo mkdir -p /var/www/html/raspialarma
sudo chown -R $USER:$USER /var/www/html/raspialarma

Dentro de esa carpeta, cread un archivo llamado por ejemplo:

recibir_datos.php

Este archivo actuará como punto de recepción de datos enviados desde las Raspberry.

¿Cómo funcionará?

La idea es que cada Raspberry envíe una petición HTTP POST al servidor central con los datos pendientes. El servidor:

• Recibe la información.
• La valida.
• La inserta en la base de datos central.
• Devuelve una respuesta indicando si el envío fue correcto.

Formato de envío recomendado

Podéis trabajar en JSON. Por ejemplo, una Raspberry podría enviar algo parecido a esto:

{
  "id_raspberry": "raspi-aula-01",
  "lecturas": [
    {
      "nombresensor": "temperatura",
      "lectura1": "24.5",
      "lectura2": null,
      "lectura3": null,
      "fecha_hora": "2026-04-21 10:15:00",
      "alumnoEncargado": "Ana",
      "descripcionSensor": "Sensor de temperatura laboratorio",
      "estado_alerta": "normal",
      "hash_registro": "abc123"
    }
  ]
}

Qué debe hacer el endpoint

El archivo recibir_datos.php deberá:

• Leer el JSON recibido.
• Comprobar que el identificador de Raspberry existe.
• Recorrer todas las lecturas recibidas.
• Insertarlas en la tabla central.
• Evitar duplicados.
• Devolver una respuesta JSON con el resultado.

Respuesta recomendada

{
  "status": "ok",
  "insertados": 5,
  "duplicados": 1
}

Mejora recomendable de seguridad

Para que no cualquier equipo mande datos falsos, podéis añadir una clave compartida o token simple.

Por ejemplo, que cada Raspberry envíe también:

• api_key
• o una cabecera personalizada

Y el servidor compruebe que coincide con la esperada.

No hace falta complicarlo demasiado: para una práctica educativa, una clave sencilla ya es suficiente para introducir el concepto de autenticación entre máquinas.

Parte 4 – Sincronización desde las Raspberry

Paso 7. Adaptar el script Python de cada Raspberry

Cada Raspberry ya guarda datos en local. Ahora deberá además:

• Consultar en su base de datos local los registros no enviados.
• Preparar un JSON con esos registros.
• Enviarlo al servidor central.
• Si el servidor responde correctamente, marcar esos registros como enviados.

Lógica del proceso

El flujo correcto debería ser este:

1. La Raspberry lee el sensor.
2. Inserta la lectura en su base local.
3. Cada cierto tiempo, otro script consulta los registros con enviado_central = 0.
4. Los envía al servidor central.
5. Si el servidor responde correctamente, esos registros pasan a enviado_central = 1.

Campo obligatorio en la base local

Recordad que la tabla local de cada Raspberry debe incluir algo como:

• id_raspberry
• estado_alerta
• enviado_central

Esto permitirá gestionar la sincronización correctamente.

Frecuencia de envío

Podéis programar el script para que se ejecute con cron cada:

• 1 minuto
• 5 minutos
• o el intervalo que considere el grupo

Eso dependerá del ritmo de captura de datos.

Parte 5 – Interfaz web del servidor central

Paso 8. Crear el panel web principal

Una vez que el servidor central ya recibe datos, habrá que crear una web que muestre toda la información agregada.

La interfaz deberá desarrollarse en PHP y deberá leer los datos desde la base de datos central.

Contenido mínimo del panel

El panel debería mostrar, como mínimo:

Vista general

• Número total de lecturas recibidas.
• Número de Raspberry activas.
• Número de sensores registrados.
• Número de alertas.

Tabla de lecturas

• ID
• Raspberry origen
• Nombre del sensor
• Lecturas
• Fecha y hora
• Estado de alerta

Filtros

• Filtrar por Raspberry
• Filtrar por sensor
• Filtrar por fecha
• Filtrar por estado de alerta

Gráficas

• Evolución temporal de un sensor
• Número de alertas por nodo
• Distribución de lecturas por tipo de sensor

Paso 9. Crear una portada tipo dashboard

Una buena práctica es construir una página principal con tarjetas o bloques visuales.

Ejemplo de bloques

• Total de nodos conectados
• Última lectura recibida
• Sensores en alerta
• Total de registros

Esto hace que el proyecto parezca mucho más profesional y permite al alumnado trabajar el diseño de interfaces orientadas a monitorización.

Paso 10. Crear gráficas con Chart.js

Para representar datos de forma visual, se recomienda utilizar Chart.js.

Ejemplos de gráficas que podéis pedir:

• Temperatura a lo largo del tiempo
• Número de lecturas por Raspberry
• Estados de alerta por tipo de sensor
• Comparativa entre varios nodos

Paso 11. Crear una página de detalle por Raspberry

Además del panel general, es muy interesante que exista una vista individual para cada Raspberry.

Esa página podría mostrar:

• Identificador del nodo
• Ubicación
• Última conexión
• Sensores asociados
• Histórico de lecturas
• Alertas detectadas

Esto da una estructura mucho más completa al proyecto.

Parte 6 – Funcionalidades extra recomendadas

Aquí es donde puedes enriquecer muchísimo el proyecto.

1. Sistema de alertas visuales

Si una lectura supera un umbral, mostrarla en rojo o destacarla visualmente.

Ejemplos:

• Temperatura demasiado alta
• Humedad anómala
• Falta de actualización de un nodo

2. Detección de Raspberry inactivas

Si una Raspberry no envía datos en un tiempo determinado, el panel puede marcarla como:

• Activa
• Inactiva
• Desconectada

Esto es muy útil en un sistema distribuido real.

3. Registro de logs

Crear una tabla o archivo de log donde quede constancia de:

• Envíos recibidos
• Fallos de sincronización
• Intentos inválidos
• Errores de base de datos

Así introducís el concepto de auditoría del sistema.

4. Histórico de incidencias

Podéis añadir una tabla para guardar incidencias detectadas:

• Fecha
• Raspberry
• Tipo de problema
• Descripción
• Estado de resolución

5. Exportación de datos

Añadir una opción para exportar lecturas en CSV.

Esto da mucho valor al proyecto porque permite luego tratar la información en Excel, LibreOffice Calc o herramientas de análisis.

6. Panel responsive

Hacer que la web se vea razonablemente bien en móvil, tablet y PC.

7. Inicio de sesión

Como ampliación, podéis pedir una pequeña autenticación en PHP para que el panel central no sea público.

8. Mapa o distribución física

Si queréis darle más fuerza visual, podéis representar cada Raspberry por ubicación o sala.

Entregables

Entregable 1 – Infraestructura

Documento con:

• Nombre del servidor
• IP
• Capturas de la VM
• Servicios instalados

Entregable 2 – Base de datos

• Script SQL de creación
• Explicación de tablas
• Justificación del diseño

Entregable 3 – Recepción de datos

• Código del endpoint
• Ejemplo de JSON recibido
• Capturas de pruebas correctas

Entregable 4 – Sincronización

• Script Python de envío
• Consulta de pendientes
• Marcado de enviados

Entregable 5 – Panel web

• Capturas del dashboard
• Tablas
• Filtros
• Gráficas

Entregable 6 – Mejoras

• Seguridad
• Logs
• Alertas
• Exportación
• Detección de nodos inactivos

Criterios de evaluación orientativos

Puedes evaluarlo así:

Diseño de arquitectura

• Claridad del planteamiento
• Separación entre nodo y central
• Coherencia técnica

Base de datos

• Estructura correcta
• Uso de claves
• Evitar duplicados
• Campos útiles

Comunicación entre sistemas

• Envío correcto de datos
• Gestión de errores
• Registros marcados como enviados

Interfaz web

• Funcionalidad
• Claridad visual
• Utilidad de filtros
• Gráficas correctas

Mejoras

• Seguridad
• Alertas
• Logs
• Exportación
• Control de nodos

Documentación

• Orden
• Explicaciones
• Capturas
• Comprensión real del sistema

Resultado final esperado

Al terminar la práctica, el alumnado habrá construido un sistema completo con esta lógica:

• Varias Raspberry recogen datos.
• Cada una los almacena localmente.
• Cada una sincroniza con el servidor central.
• El servidor central unifica la información.
• Un panel web muestra todo el sistema de manera visual y organizada.

En otras palabras, no habrán hecho solo una página PHP, sino una infraestructura distribuida de monitorización, que ya se parece bastante a una solución profesional real.

Ampliaciones que puedes realizar

Esto te puede venir bien para futuras fases del proyecto:

Envío de correos de alerta

Cuando un sensor entre en estado crítico, enviar correo automático.

API REST real

En lugar de un PHP simple, crear una pequeña API con rutas más organizadas.

Panel de administración

Permitir alta de nodos, edición de sensores y gestión de incidencias.

Copias de seguridad

Programar backups automáticos de la base de datos central.