Monitoreo Inteligente de Biorreactor con ESP32

6. Códigos Completos del Proyecto

6.1. Código Principal del ESP32 (main.py)

# main.py (Versión Final Integrada)

# --- LIBRERÍAS ---
from machine import Pin, PWM, I2C
import time
import onewire, ds18x20
from ssd1306 import SSD1306_I2C
from ads1x15 import ADS1115
import network
import urequests
import ujson

# --- CONFIGURACIÓN DE PINES Y HARDWARE ---
# Motor
pin_motor_adelante = Pin(19, Pin.OUT)
pin_motor_atras = Pin(18, Pin.OUT)
pin_velocidad_ena = Pin(5)
pwm_motor = PWM(pin_velocidad_ena, freq=1000)

# I2C (Compartido por OLED y ADS1115)
i2c = I2C(1, scl=Pin(22), sda=Pin(21))

# Pantalla OLED
pantalla = SSD1306_I2C(128, 64, i2c)

# Sensor de Temperatura
pin_onewire = Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(pin_onewire))
try:
    roms = ds_sensor.scan()
    sensor_temp_encontrado = True
    print('Sensor de temperatura encontrado:', roms)
except:
    sensor_temp_encontrado = False
    print('Error: No se encontró el sensor de temperatura.')

# Sensor de pH (ADS1115)
try:
    ads = ADS1115(i2c)
    ads.set_gain(1) # Ganancia para ±4.096V
    sensor_ph_encontrado = True
    print('Sensor ADS1115 (pH) encontrado.')
except:
    sensor_ph_encontrado = False
    print('Error: No se encontró el sensor ADS1115.')

# --- CONSTANTES DE CALIBRACIÓN DE PH ---
# !!! IMPORTANTE: REEMPLAZA ESTOS VALORES CON LOS TUYOS !!!
PENDIENTE_PH = -4.032 
INTERSECCION_PH = 17.128

# --- CONFIGURACIÓN DE RED Y SERVIDOR ---
WIFI_SSID = "AAAAAA"
WIFI_PASS = "AAAA"
URL_SERVIDOR = "http://192.168.1.118:5000/datos"

# --- PARÁMETROS DE FUNCIONAMIENTO ---
VELOCIDAD_MEZCLA = 1000
DURACION_MEZCLA_SEG = 30
TIEMPO_ESPERA_SEG = 60 # Tiempo entre ciclos de mezcla

# --- FUNCIONES ---

def conectar_wifi():
    print("Conectando a la red WiFi...")
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        wlan.connect(WIFI_SSID, WIFI_PASS)
        while not wlan.isconnected():
            print(".", end="")
            time.sleep(1)
    print("\n¡Conexión exitosa!")
    print("Configuración de red:", wlan.ifconfig())

def leer_ph_calibrado():
    if not sensor_ph_encontrado:
        return None
    try:
        raw_value = ads.read(channel=0)
        voltaje = raw_value * (4.096 / 32767.0)
        valor_ph = (PENDIENTE_PH * voltaje) + INTERSECCION_PH
        return valor_ph
    except Exception as e:
        print(f"Error leyendo el pH: {e}")
        return None

def enviar_datos_servidor(temperatura, ph_val):
    if not network.WLAN(network.STA_IF).isconnected():
        print("WiFi desconectado. No se pueden enviar datos.")
        return

    datos_a_enviar = {"temperatura": temperatura, "ph": ph_val}
    json_data = ujson.dumps(datos_a_enviar)
    
    try:
        print(f"Enviando a servidor: {json_data}")
        respuesta = urequests.post(URL_SERVIDOR, headers={'Content-Type': 'application/json'}, data=json_data)
        print(f"Respuesta: [{respuesta.status_code}] {respuesta.text}")
        respuesta.close()
    except Exception as e:
        print(f"Error al enviar datos: {e}")

def actualizar_pantalla(status, temperatura, ph_val):
    pantalla.fill(0)
    pantalla.text("Estado:", 0, 0)
    pantalla.text(status, 0, 10)
    temp_str = f"{temperatura:.1f} C" if temperatura is not None else "Error"
    ph_str = f"{ph_val:.2f}" if ph_val is not None else "Error"
    pantalla.text(f"Temp:{temp_str}", 0, 30)
    pantalla.text(f"pH:  {ph_str}", 0, 45)
    pantalla.show()

def mezclar(duracion, velocidad, temp, ph):
    actualizar_pantalla("Mezclando...", temp, ph)
    pin_motor_adelante.value(1)
    pin_motor_atras.value(0)
    pwm_motor.duty(velocidad)
    time.sleep(duracion)
    pwm_motor.duty(0)
    pin_motor_adelante.value(0)
    print("Mezcla terminada.")

# --- PROGRAMA PRINCIPAL ---
conectar_wifi()
actualizar_pantalla("Iniciando...", None, None)
time.sleep(2)

while True:
    temp_actual = None
    if sensor_temp_encontrado:
        try:
            ds_sensor.convert_temp()
            time.sleep_ms(750)
            temp_actual = ds_sensor.read_temp(roms[0])
        except:
            print("Error al leer la temperatura")
            temp_actual = None
            
    ph_actual = leer_ph_calibrado()

    actualizar_pantalla("En Espera", temp_actual, ph_actual)
    enviar_datos_servidor(temp_actual, ph_actual)
    
    print(f"Estado: En Espera. Temp: {temp_actual:.1f}C. pH: {ph_actual:.2f}. Próxima mezcla en {TIEMPO_ESPERA_SEG}s.")
    time.sleep(TIEMPO_ESPERA_SEG)
    
    mezclar(DURACION_MEZCLA_SEG, VELOCIDAD_MEZCLA, temp_actual, ph_actual)
        

6.2. Script de Calibración (calibracion_ph.py)

# calibracion_ph.py
from machine import Pin, I2C
from ads1x15 import ADS1115
import time

i2c = I2C(1, scl=Pin(22), sda=Pin(21))

try:
    ads = ADS1115(i2c)
    sensor_ph_encontrado = True
    print("Sensor ADS1115 encontrado. Listo para calibrar.")
    ads.set_gain(1) 
except Exception as e:
    sensor_ph_encontrado = False
    print(f"Error: No se encontró el sensor ADS1115. Verifica las conexiones. {e}")

if sensor_ph_encontrado:
    while True:
        try:
            raw_value = ads.read(channel=0)
            voltaje = raw_value * (4.096 / 32767.0)
            print(f"Valor Crudo ADC: {raw_value}, Voltaje Calculado: {voltaje:.4f} V")
            time.sleep(2)
        except KeyboardInterrupt:
            print("Calibración detenida.")
            break
        except Exception as e:
            print(f"Ocurrió un error: {e}")
            break
        

6.3. Scripts de la Computadora

crear_db.py

# crear_db.py
import sqlite3

DB_FILE = "sensores.db"

try:
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute('''
    CREATE TABLE IF NOT EXISTS lecturas (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
        temperatura_c REAL,
        ph_valor REAL 
    );
    ''')
    print(f"Base de datos '{DB_FILE}' y tabla 'lecturas' verificadas/creadas exitosamente.")
except Exception as e:
    print(f"Ocurrió un error al crear la base de datos: {e}")
finally:
    if 'conn' in locals() and conn:
        conn.commit()
        conn.close()
        

servidor.py

# servidor.py
from flask import Flask, request, jsonify
import sqlite3

DB_FILE = "sensores.db"
app = Flask(__name__)

@app.route('/datos', methods=['POST'])
def recibir_datos():
    try:
        datos = request.get_json()
        temp = datos.get('temperatura')
        ph = datos.get('ph')
        print(f"Dato recibido -> Temp: {temp} °C, pH: {ph}")
        conn = sqlite3.connect(DB_FILE)
        cursor = conn.cursor()
        cursor.execute("INSERT INTO lecturas (temperatura_c, ph_valor) VALUES (?, ?)", (temp, ph))
        conn.commit()
        conn.close()
        return jsonify({"status": "ok"}), 200
    except Exception as e:
        print(f"Error procesando la petición: {e}")
        return jsonify({"status": "error en el servidor"}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)
        

visualizar.py

# visualizar.py
import sqlite3
import pandas as pd
import matplotlib.pyplot as plt

DB_FILE = "sensores.db"

try:
    conn = sqlite3.connect(DB_FILE)
    query = "SELECT timestamp, temperatura_c, ph_valor FROM lecturas ORDER BY timestamp"
    df = pd.read_sql_query(query, conn)
    print("Datos cargados exitosamente desde la base de datos.")
    print("Últimas 5 lecturas:")
    print(df.tail())
except Exception as e:
    print(f"Error al leer la base de datos: {e}")
    exit()
finally:
    if 'conn' in locals() and conn:
        conn.close()

if not df.empty:
    print("Generando la gráfica...")
    plt.style.use('ggplot')
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), sharex=True)
    fig.suptitle('Monitoreo del Biorreactor', fontsize=16)

    ax1.plot(df['timestamp'], df['temperatura_c'], marker='.', linestyle='-', color='r', label='Temperatura')
    ax1.set_ylabel('Temperatura (°C)')
    ax1.legend()
    ax1.grid(True)
    
    ax2.plot(df['timestamp'], df['ph_valor'], marker='.', linestyle='-', color='b', label='pH')
    ax2.set_ylabel('Valor de pH')
    ax2.set_xlabel('Fecha y Hora')
    ax2.legend()
    ax2.grid(True)
    
    fig.autofmt_xdate()
    
    plt.tight_layout(rect=[0, 0, 1, 0.96])
    plt.show()
else:
    print("No hay datos en la base de datos para graficar.")