PROYECTO II B 2024 » Grupo 4B-2024

from kivy.app import App

from kivy.config import Config

from kivy.uix.label import Label

from kivy.uix.button import Button

from kivy.uix.floatlayout import FloatLayout

from kivy.core.window import Window

from kivy.graphics import Color, RoundedRectangle, Rectangle , Line

from kivy.uix.button import ButtonBehavior

from kivy.uix.image import Image

from kivy.uix.popup import Popup

from kivy.uix.boxlayout import BoxLayout

from kivy.uix.textinput import TextInput

from kivy.uix.screenmanager import ScreenManager, Screen

from kivy.uix.scrollview import ScrollView

from kivy.uix.progressbar import ProgressBar

from kivy.clock import Clock

import random 

# Configuración de la ventana

Config.set('graphics', 'width', '360')  # Ancho de la ventana

Config.set('graphics', 'height', '640')  # Alto de la ventana

Config.set('graphics', 'resizable', True)  # Permitir redimensionar

Config.write()

class RoundedButton(Button):

    def __init__(self, bg_color=(0.7529, 0.7529, 0.7529, 1), **kwargs):

        super().__init__(**kwargs)

        self.background_normal = ''

        self.background_down = ''

        self.background_color = (0, 0, 0, 0)

        # Personaliza el fondo redondeado con el color proporcionado

        self.bg_color = bg_color

        with self.canvas.before:

            Color(*self.bg_color)

            self.bg_rect = RoundedRectangle(

                size=self.size,

                pos=self.pos,

                radius=[(20, 20), (20, 20), (20, 20), (20, 20)]

            )

        self.bind(size=self.update_rect, pos=self.update_rect)

    def update_rect(self, *args):

        self.bg_rect.size = self.size

        self.bg_rect.pos = self.pos

class ImageButton(ButtonBehavior, Image):

    pass

class MainScreen(Screen):  # Cambié MainScreen a heredar de Screen, no de App

    def __init__(self, **kwargs):

        super(MainScreen, self).__init__(**kwargs)

        Window.clearcolor =  (0.7529, 0.7529, 0.7529, 1)  # Color 

        # Crear un FloatLayout para gestionar las posiciones

        layout = FloatLayout()

        # Crear un Label en la parte superior

        label = Label(text="¡Bienvenido", font_size='30sp', color=(2, 0, 0, 1), bold= True)  # Color rojo

        label.size_hint = None, None

        label.size = label.texture_size

        label.pos_hint = {'center_x': 0.5, 'top': 0.9}  # Posición en la parte superior

        layout.add_widget(label)

        # Crear el contenedor amarillo transparente en la parte inferior (50% de la pantalla)

        bottom_half = FloatLayout(size_hint=(1, 0.5))  # 50% de la pantalla de altura

        with bottom_half.canvas:

            Color(1, 1, 0, 0.8)  # Amarillo semi-transparente (r, g, b, alpha)

            self.rect_bottom = Rectangle(size=bottom_half.size, pos=bottom_half.pos)  # Cambiar a Rectangle

        bottom_half.bind(size=self.update_rect_bottom, pos=self.update_rect_bottom)

        bottom_half.pos_hint = {'x': 0, 'y': 0}  # Colocamos en la parte inferior

        layout.add_widget(bottom_half)

        # Crear el contenedor gris con bordes redondeados

        gray_box = FloatLayout(size_hint=(None, None), size=("300dp", "350dp"))

        gray_box.pos_hint = {'center_x': 0.5, 'y': 0.06}

        # Dibujar un fondo gris con bordes redondeados

        with gray_box.canvas:

            Color(1, 1, 1, 1)

            self.rect_gray = RoundedRectangle(size=gray_box.size, pos=gray_box.pos, radius=[(20, 20), (20, 20), (20, 20), (20, 20)])

        gray_box.bind(size=self.update_rect_gray, pos=self.update_rect_gray)

        layout.add_widget(gray_box)

        gray_box.pos = (gray_box.pos[0], gray_box.pos[1] - 50)

        # Crear un label para conectar

        label2 = Label(text="Establecer Conexión", font_size='22sp', color=(2, 0, 0, 1), bold=True)  # Color rojo

        label2.size_hint = None, None

        label2.size = label2.texture_size

        label2.pos_hint = {'center_x': 0.5, 'top': 0.5}  # Posición en la parte superior

        layout.add_widget(label2)

        # Crear el botón de conexión

        button_conect = ImageButton(

            source="conectar.png",  # Ruta de la imagen para el botón

            size_hint=(None, None),

            size=("200dp", "210dp")

        )

        button_conect.pos_hint = {'center_x': 0.5, 'center_y': 0.30}

        button_conect.bind(on_press=self.show_popup)

        layout.add_widget(button_conect)

        # Crear el logo en la parte superior

        image = Image(

            source='logo.png',

            allow_stretch=True, 

            keep_ratio=False, 

            size_hint=(None, None),  # Desactiva el tamaño relativo

            size=(150, 130)  # Asigna ancho y alto específicos

        )

        # Establecer la posición del logo

        image.pos_hint = {'center_x': 0.5, 'center_y': 0.75}  # Centrar en X y ajustar altura

        layout.add_widget(image, index=len(layout.children))  # Asegúrate de que la imagen esté delante

        self.add_widget(layout)  # Agregar el layout a la pantalla

    def show_popup(self, instance):

        # Crear un BoxLayout para el popup

        popup_layout = BoxLayout(orientation='vertical', padding=10, spacing=10)

        # Crear un campo de entrada para la IP del servidor

        ip_label = Label(text="Dirección IP del servidor:")

        ip_input = TextInput(hint_text="Ingrese la dirección IP", multiline=False)

        # Crear un botón de CONECTAR en el popup

        connect_button = Button(text="Conectar", size_hint=(None, None), size=("300dp", "50dp"))

        connect_button.bind(on_press=lambda x: self.connect_to_server(ip_input.text))  # Llamada al método para conectar

        # Agregar los elementos al layout del popup

        popup_layout.add_widget(ip_label)

        popup_layout.add_widget(ip_input)

        popup_layout.add_widget(connect_button)

        # Crear el Popup y mostrarlo

        self.popup = Popup(title="Conectar a servidor", content=popup_layout,

                           size_hint=(None, None), size=("340dp", "220dp"))

        self.popup.open()

    def show_connected_screen(self):

        # Cambiar a la pantalla de conexión exitosa

        self.manager.current = "second"  # Asegúrate de que 'second' es el nombre correcto de la pantalla

    def connect_to_server(self, ip_address):

        if ip_address == "1":  # Comprobamos si la IP es "1", solo como ejemplo

            print(f"Conectado a {ip_address}...")

            self.popup.dismiss()  # Cerrar el popup

            self.show_connected_screen()  # Cambiar a la pantalla de conexión exitosa

        else:

            print(f"Dirección IP errónea. Inténtalo de nuevo.")

            # Actualizar el campo del popup para que el usuario ingrese de nuevo

            self.popup.content.children[1].text = ""  # Limpiar el TextInput (si estás usando Kivy)

            # Aquí no terminamos la función con return, solo damos feedback al usuario y seguimos esperando

            self.popup.content.children[1].hint_text = "Ingresa una IP válida"  # Añadir texto de sugerencia para el usuario

    # Métodos para actualizar los tamaños y posiciones de los rectángulos

    def update_rect_bottom(self, instance, value):

        self.rect_bottom.pos = instance.pos

        self.rect_bottom.size = instance.size

    def update_rect_gray(self, instance, value):

        self.rect_gray.pos = instance.pos

        self.rect_gray.size = instance.size

class SecondScreen(Screen):  # Pantalla de conexión exitosa

    def __init__(self, **kwargs):

        super(SecondScreen, self).__init__(**kwargs)

        layout = FloatLayout()

        # Imagen del logo

        image = Image(

            source='logo.png',

            allow_stretch=True, 

            keep_ratio=False, 

            size_hint=(None, None),  

            size=(180, 160)

        )

        image.pos_hint = {'center_x': 0.5, 'center_y': 0.80}

        layout.add_widget(image, index=len(layout.children))

        # Contenedor amarillo en la parte inferior

        bottom_half = FloatLayout(size_hint=(1, 0.5))

        with bottom_half.canvas:

            Color(0, 0, 1, 0.8)  # Azul semi-transparente

            self.rect_bottom = Rectangle(size=bottom_half.size, pos=bottom_half.pos)

        bottom_half.bind(size=self.update_rect_bottom, pos=self.update_rect_bottom)

        bottom_half.pos_hint = {'x': 0, 'y': 0}

        layout.add_widget(bottom_half)

        # Caja gris flotante

        gray_box = FloatLayout(size_hint=(None, None), size=("300dp", "350dp"))

        gray_box.pos_hint = {'center_x': 0.5, 'y': 0.06}

        with gray_box.canvas:

            Color(1, 1, 1, 1)  # Gris claro

            self.rect_gray = RoundedRectangle(

                size=gray_box.size, pos=gray_box.pos, radius=[(20, 20), (20, 20), (20, 20), (20, 20)]

            )

        gray_box.bind(size=self.update_rect_gray, pos=self.update_rect_gray)

        layout.add_widget(gray_box)

        # Botón para la pantalla "four"

        button_to_four = RoundedButton(

            text="Ver Estado Agua",

            size_hint=(None, None),

            size=("250dp", "60dp"),

            color=(0, 0, 0, 1),

            bold=True,

            font_size='18sp'

        )

        button_to_four.pos_hint = {'center_x': 0.5, 'center_y': 0.42}

        button_to_four.bind(on_press=lambda x: self.change_screen("four"))

        layout.add_widget(button_to_four)

        # Botón para la pantalla "five"

        button_to_five = RoundedButton(

            text="Ver Estado Alimento",

            size_hint=(None, None),

            size=("250dp", "60dp"),

            color=(0, 0, 0, 1),

            bold=True,

            font_size='18sp'

        )

        button_to_five.pos_hint = {'center_x': 0.5, 'center_y': 0.28}

        button_to_five.bind(on_press=lambda x: self.change_screen("five"))

        layout.add_widget(button_to_five)

        self.add_widget(layout)

    def change_screen(self, screen_name):

        """

        Cambia a la pantalla especificada.

        """

        self.manager.current = screen_name

    def update_rect_bottom(self, instance, value):

        """

        Actualiza el tamaño y la posición del fondo azul.

        """

        self.rect_bottom.pos = instance.pos

        self.rect_bottom.size = instance.size

    def update_rect_gray(self, instance, value):

        """

        Actualiza el tamaño y la posición de la caja gris.

        """

        self.rect_gray.pos = instance.pos

        self.rect_gray.size = instance.size

from kivy.uix.screenmanager import Screen

from kivy.uix.floatlayout import FloatLayout

from kivy.uix.label import Label

from kivy.uix.image import Image

from kivy.uix.button import Button

from kivy.graphics import Color, RoundedRectangle, Line

import serial

import time

import RPi.GPIO as GPIO

class FourScreen(Screen):

    def __init__(self, **kwargs):

        super(FourScreen, self).__init__(**kwargs)

        layout = FloatLayout()

        # Imagen del logo

        image = Image(

            source='logo.png',

            allow_stretch=True,

            keep_ratio=False,

            size_hint=(None, None),

            size=(180, 160)

        )

        image.pos_hint = {'center_x': 0.5, 'center_y': 0.80}

        layout.add_widget(image, index=len(layout.children))

        # Parte inferior amarilla

        bottom_half = FloatLayout(size_hint=(1, 0.5))

        with bottom_half.canvas:

            Color(1, 1, 0, 0.8)

            self.rect_bottom = RoundedRectangle(size=bottom_half.size, pos=bottom_half.pos)

        bottom_half.bind(size=self.update_rect_bottom, pos=self.update_rect_bottom)

        bottom_half.pos_hint = {'x': 0, 'y': 0}

        layout.add_widget(bottom_half)

        # Caja gris flotante

        gray_box = FloatLayout(size_hint=(None, None), size=("300dp", "350dp"))

        gray_box.pos_hint = {'center_x': 0.5, 'y': 0.06}

        with gray_box.canvas:

            Color(1, 1, 1, 1)

            self.rect_gray = RoundedRectangle(

                size=gray_box.size,

                pos=gray_box.pos,

                radius=[(20, 20), (20, 20), (20, 20), (20, 20)]

            )

        gray_box.bind(size=self.update_rect_gray, pos=self.update_rect_gray)

        layout.add_widget(gray_box)

        # Caja de texto para mostrar información

        info_box = FloatLayout(size_hint=(None, None), size=("250dp", "200dp"))

        info_box.pos_hint = {'center_x': 0.5, 'center_y': 0.55}

        with info_box.canvas:

            Color(0.9, 0.9, 0.9, 1)

            self.info_background = RoundedRectangle(

                size=info_box.size,

                pos=info_box.pos,

                radius=[(10, 10), (10, 10), (10, 10), (10, 10)]

            )

            Color(0, 0, 0, 1)

            self.info_border = Line(

                rounded_rectangle=(info_box.x, info_box.y, info_box.width, info_box.height, 10),

                width=1.5

            )

        info_box.bind(size=self.update_info_background, pos=self.update_info_background)

        # Etiqueta para mostrar datos

        self.label = Label(

            text="Distancia: 0.00 cm\nNivel de Agua: Desconocido\nValor pH: Desconocido",

            font_size=18,

            size_hint=(None, None),

            pos_hint={"center_x": 0.5, "center_y": 0.5},

            color=(0, 0, 0, 1)

        )

        info_box.add_widget(self.label)

        layout.add_widget(info_box)

        # Botón para medir nivel de agua y pH

        medir_button = Button(

            text="Medir Nivel de Agua",

            size_hint=(None, None),

            size=("250dp", "50dp"),

            font_size='18sp'

        )

        medir_button.pos_hint = {'center_x': 0.5, 'center_y': 0.35}

        medir_button.bind(on_press=self.check_water_level)

        layout.add_widget(medir_button)

        # Botón para suministrar agua

        suministrar_button = Button(

            text="Suministrar Agua",

            size_hint=(None, None),

            size=("250dp", "50dp"),

            font_size='18sp'

        )

        suministrar_button.pos_hint = {'center_x': 0.5, 'center_y': 0.25}

        suministrar_button.bind(on_press=self.suministrar_agua)

        layout.add_widget(suministrar_button)

        # Botón para limpiar agua

        limpiar_button = Button(

            text="Limpiar Agua",

            size_hint=(None, None),

            size=("250dp", "50dp"),

            font_size='18sp'

        )

        limpiar_button.pos_hint = {'center_x': 0.5, 'center_y': 0.15}

        limpiar_button.bind(on_press=self.limpiar_agua)

        layout.add_widget(limpiar_button)

        # Botón para regresar

        back_button = Button(

            text="Volver",

            size_hint=(None, None),

            size=("250dp", "50dp"),

            background_color=(1, 0, 0, 1),

            font_size='18sp'

        )

        back_button.pos_hint = {'center_x': 0.5, 'center_y': 0.05}

        back_button.bind(on_press=lambda x: self.change_screen("second"))

        layout.add_widget(back_button)

        self.add_widget(layout)

    def check_water_level(self, instance):

        print("Botón 'Medir Nivel de Agua' presionado")

        distancia = self.medir_distancia()

        ph_valor = self.leer_ph()

        # Validar y manejar posibles valores nulos

        if distancia is None:

            distancia_text = "Error"

            estado = "Desconocido"

        else:

            distancia_text = f"{distancia:.2f}"

            if 5 <= distancia <= 8:

                estado = "Lleno"

            elif 8.1 <= distancia <= 13:

                estado = "Normal"

            else:

                estado = "Vacío"

        ph_valor = ph_valor if ph_valor else "Error"

        self.label.text = f"Distancia: {distancia_text} cm\nNivel de Agua: {estado}\nValor pH: {ph_valor}"

        print(f"Distancia medida: {distancia_text} cm - Nivel de Agua: {estado} - Valor pH: {ph_valor}")

    def suministrar_agua(self, instance):

        try:

            puerto_arduino = '/dev/ttyUSB0'

            baud_rate = 9600

            print("Intentando conectar al Arduino...")

            arduino = serial.Serial(puerto_arduino, baud_rate, timeout=1)

            time.sleep(2)

            print("Abriendo válvula...")

            arduino.write(b'1')

            time.sleep(30)

            print("Cerrando válvula...")

            arduino.write(b'0')

        except Exception as e:

            print(f"Error al suministrar agua: {e}")

            self.label.text = "Error al suministrar agua."

        finally:

            try:

                arduino.close()

                print("Conexión serial cerrada.")

            except:

                pass

    def limpiar_agua(self, instance):

        print("Función de limpiar agua aún no implementada.")

    def medir_distancia(self):

        GPIO.setmode(GPIO.BCM)

        TRIG = 3

        ECHO = 4

        GPIO.setup(TRIG, GPIO.OUT)

        GPIO.setup(ECHO, GPIO.IN)

        try:

            GPIO.output(TRIG, False)

            time.sleep(2)

            GPIO.output(TRIG, True)

            time.sleep(0.00001)

            GPIO.output(TRIG, False)

            while GPIO.input(ECHO) == 0:

                pulso_inicio = time.time()

            while GPIO.input(ECHO) == 1:

                pulso_fin = time.time()

            duracion_pulso = pulso_fin - pulso_inicio

            return round(duracion_pulso * 17150, 2)

        except Exception as e:

            print(f"Error al medir distancia: {e}")

            return None

        finally:

            GPIO.cleanup()

    def leer_ph(self):

        try:

            arduino = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)

            time.sleep(2)

            if arduino.in_waiting > 0:

                return arduino.readline().decode('utf-8').strip()

        except Exception as e:

            print(f"Error al leer pH: {e}")

            return None

        finally:

            try:

                arduino.close()

            except:

                pass

    def update_info_background(self, instance, value):

        self.info_background.size = instance.size

        self.info_background.pos = instance.pos

        self.info_border.rounded_rectangle = (

            instance.x, instance.y, instance.width, instance.height, 10

        )

    def update_rect_bottom(self, instance, value):

        self.rect_bottom.pos = instance.pos

        self.rect_bottom.size = instance.size

    def update_rect_gray(self, instance, value):

        self.rect_gray.pos = instance.pos

        self.rect_gray.size = instance.size

    def change_screen(self, screen_name):

        self.manager.current = screen_name

import RPi.GPIO as GPIO

import time

from kivy.uix.image import Image

from kivy.uix.label import Label

from kivy.uix.button import Button

from kivy.uix.floatlayout import FloatLayout

from kivy.graphics import Color, RoundedRectangle

class FiveScreen(Screen):  # Pantalla de Ver Estado Alimento

    def __init__(self, **kwargs):

        super(FiveScreen, self).__init__(**kwargs)

        layout = FloatLayout()

        # Imagen del logo

        image = Image(

            source='logo.png',

            allow_stretch=True,

            keep_ratio=False,

            size_hint=(None, None),

            size=("180dp", "160dp")

        )

        image.pos_hint = {'center_x': 0.5, 'center_y': 0.80}

        layout.add_widget(image)

        # Parte inferior amarilla

        with layout.canvas.before:

            Color(1, 1, 0, 0.8)  # Amarillo semi-transparente

            self.rect_bottom = RoundedRectangle(size=(300, 100), pos=(0, 0))

        # Caja gris flotante

        gray_box = FloatLayout(size_hint=(None, None), size=("300dp", "350dp"))

        gray_box.pos_hint = {'center_x': 0.5, 'y': 0.06}

        with gray_box.canvas:

            Color(1, 1, 1, 1)  # Blanco

            self.rect_gray = RoundedRectangle(

                size=gray_box.size,

                pos=gray_box.pos,

                radius=[(20, 20), (20, 20), (20, 20), (20, 20)]

            )

        layout.add_widget(gray_box)

        # Etiqueta para mostrar datos

        self.label = Label(

            text="Estado del Alimento:\nDesconocido",

            font_size=18,

            size_hint=(1, 1),

            pos_hint={"center_x": 0.5, "center_y": 0.5},

            color=(0, 0, 0, 1),

            halign="center",

            valign="middle"

        )

        layout.add_widget(self.label)

        # Botón para medir nivel de alimento

        check_food_button = Button(

            text="Ver Nivel de Alimento",

            size_hint=(None, None),

            size=("250dp", "60dp"),

            background_color=(0, 1, 0, 1),

            pos_hint={'center_x': 0.5, 'center_y': 0.4}

        )

        check_food_button.bind(on_press=self.check_food_level)

        layout.add_widget(check_food_button)

        # Botón para suministrar alimento

        supply_button = Button(

            text="Suministrar Alimento",

            size_hint=(None, None),

            size=("250dp", "60dp"),

            background_color=(0, 1, 0, 1),

            pos_hint={'center_x': 0.5, 'center_y': 0.35}

        )

        supply_button.bind(on_press=self.supply_food)

        layout.add_widget(supply_button)

        # Botón para regresar

        back_button = Button(

            text="Volver",

            size_hint=(None, None),

            size=("250dp", "60dp"),

            background_color=(1, 0, 0, 1),

            pos_hint={'center_x': 0.5, 'center_y': 0.2}

        )

        back_button.bind(on_press=lambda x: self.change_screen("second"))

        layout.add_widget(back_button)

        self.add_widget(layout)

    def on_enter(self):

        """

        Configura los GPIO necesarios al entrar a la pantalla.

        """

        try:

            GPIO.setwarnings(False)

            GPIO.cleanup()  # Limpia cualquier configuración previa

            GPIO.setmode(GPIO.BCM)

            # Configuración del sensor HX711

            self.dout = 5

            self.pd_sck = 6

            GPIO.setup(self.dout, GPIO.IN)

            GPIO.setup(self.pd_sck, GPIO.OUT)

            GPIO.output(self.pd_sck, False)

            self.offset = 0

            self.scale = 500  # Ajusta la escala según tu sensor

            self.tare()

            # Configuración del servomotor

            self.servo_pin = 9

            GPIO.setup(self.servo_pin, GPIO.OUT)

            self.pwm = GPIO.PWM(self.servo_pin, 50)  # Frecuencia de 50 Hz

            self.pwm.start(0)

        except Exception as e:

            print(f"Error al configurar GPIO en FiveScreen: {e}")

    def on_leave(self):

        """

        Limpia los recursos GPIO utilizados al salir.

        """

        try:

            self.pwm.stop()  # Detiene el PWM

            GPIO.cleanup([self.dout, self.pd_sck, self.servo_pin])  # Limpia solo los pines utilizados por esta pantalla

        except Exception as e:

            print(f"Error al limpiar GPIO en FiveScreen: {e}")

    def tare(self):

        """

        Calibra el sensor HX711 para establecer el offset.

        """

        print("Calibrando... Por favor, no coloque peso.")

        time.sleep(5)

        self.offset = self.read_raw()

        print("Calibración completa. Puede colocar peso.")

    def read_raw(self):

        """

        Lee el valor bruto del sensor HX711.

        """

        while GPIO.input(self.dout) == 1:

            pass

        count = 0

        for _ in range(24):

            GPIO.output(self.pd_sck, True)

            count = count << 1

            GPIO.output(self.pd_sck, False)

            if GPIO.input(self.dout):

                count += 1

        GPIO.output(self.pd_sck, True)

        GPIO.output(self.pd_sck, False)

        if count & 0x800000:

            count -= 0x1000000

        return count

    def get_units(self, readings=10):

        """

        Devuelve el peso en unidades calibradas.

        """

        total = 0

        for _ in range(readings):

            total += self.read_raw() - self.offset

        average = total / readings

        return average / self.scale

    def check_food_level(self, instance):

        """

        Mide el nivel de alimento y actualiza el texto.

        """

        try:

            weight = self.get_units(10)

            if weight <= 0.05:

                estado = "Vacío"

            else:

                estado = "Lleno"

            self.label.text = f"Peso: {weight:.2f} g\nEstado del Alimento: {estado}"

            print(f"Peso medido: {weight:.2f} g - Estado del Alimento: {estado}")

        except Exception as e:

            print(f"Error al medir el nivel de alimento: {e}")

            self.label.text = "Error al medir el nivel de alimento."

    def set_angle(self, angle):

        """

        Configura el ángulo del servomotor.

        """

        duty_cycle = 2 + (angle / 18)

        self.pwm.ChangeDutyCycle(duty_cycle)

        time.sleep(0.5)

    def supply_food(self, instance):

        """

        Controla el servomotor para suministrar alimento.

        """

        try:

            self.label.text = "Suministrando alimento..."

            print("Moviendo servomotor a 90 grados.")

            self.set_angle(90)  # Gira a 90 grados

            time.sleep(3)       # Mantiene la posición durante 3 segundos

            print("Regresando servomotor a la posición inicial.")

            self.set_angle(0)   # Regresa a 0 grados

            self.pwm.ChangeDutyCycle(0)  # Detiene el PWM

            self.label.text = "Estado del Alimento:\nSuministrado."

        except Exception as e:

            print(f"Error al suministrar alimento: {e}")

            self.label.text = "Error al suministrar alimento."

    def change_screen(self, screen_name):

        """

        Cambia a la pantalla especificada.

        """

        self.manager.current = screen_name

# Inicialización de la aplicación

class MyApp(App):

    def build(self):

        # Crear el ScreenManager

        sm = ScreenManager()

        # Agregar las pantallas al ScreenManager

        sm.add_widget(MainScreen(name="main"))

        sm.add_widget(SecondScreen(name="second"))

        sm.add_widget(FourScreen(name="four"))

        sm.add_widget(FiveScreen(name="five"))

        return sm

if __name__ == "__main__":

    MyApp().run()