Proyecto 1 2024 » Grupo 5 A

h1. Servidor

<pre><code class="python">

import time

import glob

import json

import requests

import os

import random

from datetime import datetime

import grovepi

from grovepi import *

from grove_rgb_lcd import *

from gpiozero import AngularServo

import firebase_admin

from firebase_admin import credentials, firestore, messaging

# Archivos Locales

FILE_ID = "savenemo_id.txt"

FILE_CONFIG_LOCAL = "config.json"

FILE_CREDENTIALS = "serviceAccountKey.json"

# Configuracion Sensor Temperatura

SENSOR_TEMP_ID = "28-00000053d2ea"

SENSOR_TEMP_PATH = f"/sys/bus/w1/devices/{SENSOR_TEMP_ID}/w1_slave"

# Puertos GrovePi

PORT_ULTRASONIC  = 8   # D8

PORT_RELAY_CAL   = 3   # D3 (Calefactor)

PORT_PH          = 0   # A0

PORT_SENSOR_LUZ  = 1   # A1

SERVO_PIN = 18         # Pin GPIO (Servomotor)

# Variables Globales de Hardware

alimentador_servo = None 

# Configuracion Inicial por Defecto

DEFAULT_CONFIG = {

    "nombre_pez": "Esperando App...",

    "temp_min": 24.0, "temp_max": 28.0,

    "ph_min": 6.5, "ph_max": 7.5,

    "nivel_luz": 50, "nivel_agua": 80,

    "horarios_comida": [],

    "sistema_alimentacion_on": True 

}

# Estado del Sistema

config_actual = DEFAULT_CONFIG.copy()

nemo_id = ""

db = None

firebase_activo = False

ultimo_minuto_alimentacion = "" 

ya_se_envio_notificacion = False

# Funciones BD

def obtener_id_unico():

    """Lee o genera un ID unico para identificar esta pecera."""

    if os.path.exists(FILE_ID):

        with open(FILE_ID, 'r') as f:

            return f.read().strip()

    else:

        nuevo_id = f"NEMO-{random.randint(1000, 9999)}"

        with open(FILE_ID, 'w') as f:

            f.write(nuevo_id)

        return nuevo_id

def verificar_internet():

    try:

        requests.get('https://www.google.com', timeout=3)

        return True

    except: return False

def esperar_internet():

    print("Buscando conexion a internet...")

    while not verificar_internet():

        time.sleep(3)

    print("Conexion establecida.")

def iniciar_firebase():

    global db, firebase_activo

    try:

        if os.path.exists(FILE_CREDENTIALS):

            cred = credentials.Certificate(FILE_CREDENTIALS)

            if not firebase_admin._apps:

                firebase_admin.initialize_app(cred)

            db = firestore.client()

            firebase_activo = True

            print("Firebase conectado exitosamente.")

        else:

            print("Falta archivo serviceAccountKey.json")

    except Exception as e:

        print(f"Error Firebase: {e}")

        firebase_activo = False

def sincronizar_configuracion():

    global config_actual

    if not firebase_activo: return

    try:

        doc = db.collection('acuarios').document(nemo_id).collection('data').document('config').get()

        if doc.exists:

            datos = doc.to_dict()

            if datos != config_actual: # Solo actualizar si hay cambios

                print("Configuracion actualizada desde la nube.")

                config_actual.update(datos)

                with open(FILE_CONFIG_LOCAL, 'w') as f: json.dump(config_actual, f)

    except: pass

def subir_estado(temp, ph, luz, agua, alertas):

    """Sube los datos de sensores a Firestore."""

    if not firebase_activo: return

    try:

        db.collection('acuarios').document(nemo_id).collection('data').document('estado').set({

            'temp_actual': temp, 'ph_actual': ph, 'luz_actual': luz, 'agua_nivel': agua,

            'alertas': alertas, 'ultima_actualizacion': datetime.now().isoformat()

        })

    except: pass

def enviar_notificacion_push(titulo, mensaje):

    if not firebase_activo: return

    try:

        tokens_ref = db.collection('acuarios').document(nemo_id).collection('data').document('tokens')

        doc = tokens_ref.get()

        token = doc.to_dict().get('token_celular') if doc.exists else None

        if token:

            msg = messaging.Message(

                notification=messaging.Notification(title=titulo, body=mensaje),

                token=token,

            )

            messaging.send(msg)

            print(f"Push enviado: {titulo}")

    except Exception as e: 

        print(f"Error push: {e}")

def guardar_historial_evento(titulo, mensaje):

    if not firebase_activo: return

    try:

        db.collection('acuarios').document(nemo_id).collection('historial').add({

            'titulo': titulo,

            'mensaje': mensaje,

            'fecha': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),

            'timestamp': datetime.now().timestamp()

        })

    except: pass

# Hardware

def inicializar_hardware():

    global alimentador_servo

    try:

        # Relay

        pinMode(PORT_RELAY_CAL, "OUTPUT")

        digitalWrite(PORT_RELAY_CAL, 0)

        # LCD

        try:

            setText("INICIANDO\nSISTEMA...")

            setRGB(0, 0, 255) # Azul

        except: print("LCD no detectado (continuando...)")

        # Servo Motor

        alimentador_servo = AngularServo(SERVO_PIN, min_angle=0, max_angle=180, 

                                         min_pulse_width=0.0006, max_pulse_width=0.0024)

        print("Hardware inicializado correctamente.")

    except Exception as e:

        print(f"Error Hardware: {e}")

        alimentador_servo = None

# Sensores

def leer_temperatura():

    try:

        if not os.path.exists(SENSOR_TEMP_PATH):

            print("Sensor de temperatura no encontrado (Cable desconectado?)")

            return 25.0

        with open(SENSOR_TEMP_PATH, 'r') as f:

            lineas = f.readlines()

        if lineas[0].strip()[-3:] == 'YES':

            posicion_t = lineas[1].find('t=')

            if posicion_t != -1:

                temp_string = lineas[1][posicion_t+2:]

                temp_c = float(temp_string) / 1000.0

                return round(temp_c, 2)

    except Exception as e:

        print(f"Error leyendo temp: {e}")

    return 25.0

def leer_ph():

    VOLTAJE_NEUTRO = 2.50   

    FACTOR_CONVERSION = 4.17 

    try:

        valor_raw = grovepi.analogRead(PORT_PH)

        voltaje = float(valor_raw) * 5.0 / 1023

        ph_actual = 7.0 + ((voltaje - VOLTAJE_NEUTRO) * FACTOR_CONVERSION)

        return round(ph_actual, 1)

    except: return 7.0

def leer_nivel_agua():

    try:

        altura_total = 40

        dist = ultrasonicRead(PORT_ULTRASONIC)

        if dist > altura_total: dist = 40

        porc = int(100 - ((dist / altura_total) * 100))

        return max(0, min(100, porc))

    except: return 80

def leer_luz():

    try:

        lectura = analogRead(PORT_SENSOR_LUZ)

        return int((lectura / 800.0) * 100)

    except: return 50

# Actuadores

def gestionar_calefactor(temp_actual):

    target = float(config_actual.get('temp_min', 24.0))

    if temp_actual < target:

        digitalWrite(PORT_RELAY_CAL, 1) # Encender

        return True

    elif temp_actual > target + 0.5:

        digitalWrite(PORT_RELAY_CAL, 0) # Apagar

        return False

    return False

def mover_servo_alimentar():

    if alimentador_servo is None: return False

    try:

        print("Dispensando comida...")

        alimentador_servo.angle = 90

        time.sleep(0.8) 

        alimentador_servo.angle = 110

        time.sleep(0.3)

        alimentador_servo.angle = 90

        time.sleep(0.3)

        alimentador_servo.angle = 0

        time.sleep(1)

        alimentador_servo.value = None 

        return True

    except Exception as e:

        print(f"Error Servo: {e}")

        return False

def gestionar_comida():

    global ultimo_minuto_alimentacion

    if not config_actual.get('sistema_alimentacion_on', True): 

        return False

    hora_actual = datetime.now().strftime("%H:%M")

    horarios = config_actual.get("horarios_comida", [])

    if (hora_actual in horarios) and (hora_actual != ultimo_minuto_alimentacion):

        print(f"Intentando alimentar ({hora_actual})...")

        exito = mover_servo_alimentar()

        if exito:

            ultimo_minuto_alimentacion = hora_actual

            # EMOJI REMOVIDO AQUI

            enviar_notificacion_push("Hora de comer!", f"Tu pez ha sido alimentado a las {hora_actual}")

            guardar_historial_evento("Comida Servida", "Dispensador automatico activado con exito.")

            return True

    return False

def actualizar_lcd(nemo_id, temp, ph, luz, agua, calefactor_on, comida_servida):

    try:

        if comida_servida:

            setText("   DISPENSANDO\n    COMIDA...")

            time.sleep(3)

            return

        if calefactor_on: setRGB(255, 60, 0) # Naranja

        else: setRGB(0, 255, 0) # Verde

        setText(f"ID:{nemo_id}\nT:{temp}C  pH:{ph}")

        time.sleep(4)

        setText(f"ID:{nemo_id}\nLuz:{luz}% Agua:{agua}%")

        time.sleep(4)

    except: pass

def main():

    global nemo_id, ya_se_envio_notificacion

    print("\n--- INICIANDO SAVENEMO ---")

    inicializar_hardware()

    nemo_id = obtener_id_unico()

    print(f"ID DISPOSITIVO: {nemo_id}")

    esperar_internet()

    iniciar_firebase()

    print("Loop principal iniciado.\n")

    while True:

        try:

            sincronizar_configuracion()

            temp = leer_temperatura()

            ph = leer_ph()

            agua = leer_nivel_agua()

            luz = leer_luz()

            alertas = []

            cfg = config_actual

            if temp < float(cfg.get('temp_min', 20)): alertas.append("Temp Baja")

            if temp > float(cfg.get('temp_max', 35)): alertas.append("Temp Alta")

            if agua < int(cfg.get('nivel_agua', 80)): alertas.append("Nivel Bajo")

            if ph < int(cfg.get('ph_min', 80)): alertas.append("PH Bajo")

            if ph > int(cfg.get('ph_max', 80)): alertas.append("PH Alto")

            calefactor_on = gestionar_calefactor(temp)

            comida_servida = gestionar_comida()

            if alertas:

                if not ya_se_envio_notificacion:

                    print(f"Alertas: {alertas}")

                    # EMOJI REMOVIDO AQUI

                    enviar_notificacion_push("ALERTA ACUARIO ", f"Atencion: {', '.join(alertas)}")

                    guardar_historial_evento("Alerta Detectada", ', '.join(alertas))

                    ya_se_envio_notificacion = True

            else:

                if ya_se_envio_notificacion: ya_se_envio_notificacion = False

            subir_estado(temp, ph, luz, agua, alertas)

            cal_status = 'ON' if calefactor_on else 'OFF'

            # Solo para ver por terminal

            print(f"[{datetime.now().strftime('%H:%M')}] T:{temp}C pH:{ph} L:{luz}% A:{agua}% Cal:{cal_status}")

            actualizar_lcd(nemo_id, temp, ph, luz, agua, calefactor_on, comida_servida)

        except KeyboardInterrupt:

            print("\nApagando sistema...")

            try:

                digitalWrite(PORT_RELAY_CAL, 0)

                setRGB(0, 0, 0)

                setText("")

                if alimentador_servo: alimentador_servo.detach()

            except: pass

            break

        except Exception as e:

            print(f"Error en Loop: {e}")

            time.sleep(5)

if __name__ == "__main__":

    main()

</code></pre>