Alimentador automático para macotas

Introducción

Este proyecto fue motivado pensando en las personas que tienen mascotas pero que por distintos motivos no están siempre en la casa para alimentar a sus macotas en el horario que corresponde. También sirve para adultos muy mayores o personas con problemas de movilidad. Trae como beneficio que es de gran utilidad para cualquier persona que tenga mascotas, pues permite alimentarlas sin hacer un gran esfuerzo. Además ayuda a que tu mascota agarre el habito de comer siempre en un mismo horario.

La idea es hacer un alimentador que alimente automáticamente siempre en los mismos horarios (definidos previamente). Además se le podrían añadir más funcionalidades útiles, entre ellas esta dar un mensaje al dueño avisándole cuando quede poca comida y tenga que recargar, o dar la posibilidad de que el dueño le dé un pequeño “premio” a su mascota en cualquier horario, si es deseado, solo apretando un botón.

Materiales

• Kit robótico butia que incluya un motor, un sensor de distancia, un sensor de grises y un botón
• Computadora portátil con Python o turtleBots instalado.
• Cables
• Pote de comida para mascotas
• Cinta aisladora blanca o negra
• Marcador
• Tijeras y trincheta
• Pegamento
• Bidon de 5 o 6 litros
• Bandejas o platos descartables de poliestireno
• Cartón
• Papel blanco o negro
• Bandas elásticas
• Rollo de papel higiénico
• Hilo grueso o cuerdas
• Taco fischer, lapicera o cilindro pequeño
• Regla

El pegamento que se utilizo fue silicona fría, pero pueden ser otros mientras no arruinen el material que estamos pegando. Como se puede ver todos los materiales (menos el kit butia) son reciclados así no implica un gasto extra y además les damos un buen uso a cosas que podemos encontrar en nuestra casa

Planificación de la estructura

Diseñaremos un alimentador que permita pasar la comida tapando y destapando un orificio. La tapa debería girar con ayuda del motor sobre un eje que este a un borde para poder permitir el paso de la comida. La imagen es una ilustración de como se movería. El motor esta dibujado en rojo, la tapa en negro y el alimentador en gris.

Dado que la comida ejerce peso sobre la tapa y estamos usando materiales reciclados, controlaremos que no se deforme y cierre mal (debido a que cambia el ángulo) mediante un sensor de grises. La tapa será blanca y tendrá una parte negra a la que el sensor debe apuntar cuando este cerrado. De esta manera si termina de alimentar y el sensor no detecta esa parte negra significa que no cerro del todo y seguirá girando la tapa hasta encontrarla (también esta la alternativa de hacer la tapa negra con una marca blanca).

Construcción de la estructura

Paso 1: Desarmado del kit Tomar nuestro robot butia y sacarle la rueda a uno de los motores. Luego terminar de quitar el motor sacando los tornillos que lo sujetaban

Paso 2:

Sacar la plataforma que tenia la placa quitando los tornillos que la sujetaban con el resto del robot butia Si conectamos el motor con la placa se vería como en la foto:

Paso 3: Contenedor del alimentador

Tomar un bidón de 5 litros vacío y cortarle la parte de abajo con trincheta a unos 4 cm de la base del bidón aproximadamente, aquí depositaremos las comida En la foto se muestra el bidón antes de ser cortado

Paso 4: (Opcional)

Tomar un pequeño cilindro que tenga un hueco de aproximadamente 5 milímetros de diámetro donde el motor entre y quede ajustado. Este cilindro es el que estará pegado luego a la tapa del alimentador En este caso usamos un taco Fischer y le cortamos con trincheta una parte

Alternativas: Se pueden desarmar lapiceras que ya no anden y usar la parte cilíndrica, cortándola un poco En general cualquier cilindro hueco que sea un poquito mas grande y quede flojo se puede pegar con pegamento al motor, lo importante que quede ajustado y así cuando se mueva el motor mueva el cilindro Si no se consigue un cilindro adecuado podemos saltar este paso, y pegar el motor directamente a la tapa del alimentador

Paso 5: Tapa del alimentador Trazar en una bandeja descartable de poliestireno o cartón una circunferencia de 6 cm de diámetro aproximadamente y recortar con tijera Si el material no es muy rígido trazar otra y pegar ambas circunferencias con pegamento Si el material de nuestra tapa es blanco o negro dejarlo así, sino cortar una circunferencia de papel blanco o negro y pegarla a la tapa.

A un centímetro aproximadamente de un borde de nuestra tapa hacemos un pequeño tajo del tamaño del diámetro del cilindro que colocamos en el motor. Colocamos el cilindro con el motor por el tajo y pegamos con pegamento Colocar cinta aisladora (o papel) del color opuesto a nuestra tapa en un costado como se ve en la imagen. Esto es para que el sensor de grises detecte el cambio y pueda corroborar que quede bien cerrado una vez alimente

Paso 6: (Opcional) Tomar un cilindro del tamaño de la boca de nuestro bidón, puede ser el rollo del papel higiénico. Este será el conector entre el motor y el contenedor de comida Para darle más rigidez se puede cortar un un rectángulo de una bandeja de plástico de la altura del cilindro y perímetro de la base para colocarlo dentro.

Paso 7: Unir todo

Unir el motor con banditas elásticas a nuestro cilindro o pegándolo con pegamento de modo que la tapa quede rozando el cilindro Colocar el otro lado del cilindro en la boca del bidón y pegarlo con pegamento para que no se mueva

Alternativa: Si decidieron no usar el cilindro se puede pegar directamente el motor con el bidón pero no puede quedar torcido, por eso se recomienda seguir el paso anterior

Así se vería todo unido

Observar que es importante que la cinta negra que pusimos en la tapa debe queda del lado opuesto al rollo papel higiénico

Paso 8:

Encontrar una estructura donde podamos atar el alimentador (también puede pegarse) y que queda a una distancia de aproximadamente el ancho de la plataforma del kit butia (pues lo podremos de parado luego) más 2 centímetros Se recomienda que sea en una esquina

Paso 9: Sacarle la otra rueda y motor a la estructura del butia y colocarle el sensor de grises como se ve en la imagen Colocarlo parado contra la pared, junto a donde esta el alimentador

Así se vería con el pote de comida abajo incluido Notar que el sensor de grises queda a aproximadamente dos centímetros de la tapa si tomamos bien las medidas. Verificar que el led del sensor apunte a la parte negra de la tapa.

Paso 10: Atar la estructura que tiene a la placa al costado del bidón Asegurarse que quede bien sujeta Esta posición es considerando que los cables que tenemos no son muy largos y tiene que llegar a conectar todos los sensores que usemos, con cables mas largos podría estar en otro lado

Paso 11: Conectar todo

Traer la computadora portátil y colocarla de modo que llegue a conectarse con la placa Traer la fuente, colocarla en el suelo y conectarla con la placa Terminar de conectar el motor y el sensor de grises con la placa

Así quedaría todo conectado!

Verificar que el led del sensor de gris apunte a la parte oscura

Hasta aquí hemos armado la estructura de un alimentador básico que alimente cada cierto periodo de tiempo, pero para añadirle mas funcionalidades como que alimente cuando lo indico con un botón o que me avise cuando queda poca comida debemos añadirle mas sensores!

Paso 12:

Tomar un cartón o plato descartable que usaremos como parte superior del alimentador Aquí atornillaremos el sensor de distancia

Y así quedaría puesto en la parte superior del alimentador y conectado a la placa Por ultimo conectamos un botón a la placa, con un cable suficientemente largo podemos colocar el botón en un lugar a específico nuestro alcance

Paso 13: Opcional

Podemos hacer dos líneas con marcador en el bidón para señalizar determinadas cantidades de comida La línea mas abajo es el limite, por lo que si el sensor de distancia detecta menos comida que esa línea debe notificar La línea mas arriba es para cuando quiero que el alimentador vuelva a funcionar con normalidad porque ya recargue suficiente comida

Planificacion del codigo

Haremos dos códigos distintos, uno más simplificado y otro más complejo El código mas simple será en TurtleBots: en este el alimentador alimentara cada cierto periodo de tiempo (aproximadamente 3 horas) ya que no tenemos tanto manejo del tiempo. Este código es de prueba, y se detendrá cada vez que detecte poca comida El código mas complejo y completo será en Phyton, en el cual el alimentador alimente en ciertas horas que elija. Este código se ajusta más a la realidad ya que el programa quedaría andando continuamente (si queda poca comida espera a recarguen y sigue ejecutando) y alimentando de manera adecuada

Antes de empezar el código es importante tomar las siguientes medidas: En que valor del sensor distancia detecta que queda poca comida (Poner comida en el alimentador hasta la línea de más abajo y anotar valor del sensor) En que valor del sensor distancia detecta que ya se recargo suficiente comida (Poner comida en el alimentador hasta la línea de más arriba y anotar valor del sensor) En que valor del sensor gris detecta el negro de la tapa para verificar que este cerrado

Código

En TurtleBots

¿Que debemos programar?

Un programa principal que verifique si hay suficiente comida, de no ser así que notifique con un mensaje y que alimente cada cierto periodo de tiempo y cuando se lo indique presionando el botón Una función alimentar que mueva el motor para dejar pasar la comida Una función VerificarComida que avise al dueño cuando queda poca comida

Paso 1: El primer paso es agregar las extensiones señaladas en la siguiente imagen y reiniciar TurtleBots para que se actualice

Paso 2: Crear función alimentar Tomamos una caja de acción y la llamamos alimentar. Dentro de la caja movemos el motor para un lado y luego para asegurarnos de que quede cerrado lo movemos para el otro hasta que el sensor de gris detecte el negro (medida que tomamos previamente)

ADVERTENCIA! Los valores de la velocidad en la que debe moverse el motor o cuanto debe esperar pueden variar dependiendo de la estructura del alimentador Si estos valores no funcionan, hay que probar subiendo o bajando la velocidad, aumentando o disminuyendo el tiempo de espera, hasta que el alimentador deje pasar la cantidad de comida que deseamos

Paso 3: Crear función VerificarComida Una vez el valor tomado previamente cuando hay poca comida, tomamos una caja de acción y la llamamos VerificarComida Dentro de la caja colocamos un if que ejecute un determinado código si el valor del sensor de distancia es mayor a la muestra tomada (o sea que hay poca comida)

Si queda poca comida debemos ser notificados, por lo que adentro del if debemos desplegar en pantalla una señal de que queda poca comida y hay que recargar Además cambiamos el valor de una variable hayComida a 0 ya que no queda mucha

Paso 4: Crear programa principal

Primero guardamos un 1 en la variable hayComida para indicarle al programa que mientras haya comida siga ejecutando Para ello usamos un while y una vez comience llamamos a la función alimentar Cada vez que alimentemos debemos asegurarnos de llamar a la función VerificarComida

Una vez que alimentamos repetimos el siguiente código: Si el botón es apretado debe alimentador y luego verificar si queda poca comida Luego espera 1 segundo y sigue repitiendo Si queremos que alimente cada aproximadamente 3 horas debemos repetirlo 10800 veces (1 hora = 3600 segundos, 3 horas = 10800 segundos)

Programa completo:

Observar que una vez termina vuelve a alimentar si es que hay comida Si apretamos el botón en medio de esas 3 horas la próxima alimentación va a tardar un poco más (ya que alimentar toma un par de segundos extras)

En Python

Diseñaremos el código del alimentador pensándolo como una maquina de estados, donde tendría 3 estados abierto (cuando la tapa deja pasar comida), cerrado (cuando la tapa impide el paso de comida) y sin comida (un caso particular del cerrado sumado a que no puede “abrirse” para alimentar ya que no hay comida)

Estado cerrado: Lo primero que deberíamos hacer es verificar que haya comida y si no es así, pasar al estado sin comida y notificar. Si hay comida y se detecta que alguien apretó el botón o llego la hora de alimentar, deberíamos alimentar y pasar al estado abierto.

Estado abierto: Lo único que debemos hacer aquí es cerrar cuando termine de alimentar y pasar a estado cerrado.

Estado sin comida: Este estado debería revisar continuamente si ya se recargo suficiente comida y una vez esto pase volver al estado cerrado y avisar que hay comida.

Diagrama de los estados que especifica transiciones de un estado a otro

Paso 1: Importar librerías

Librerias de manejo del tiempo

import time

import datetime

from datetime import datetime

Libreria sys y Pybot necesarias para el butia

import sys

sys.path.insert(0,'/home/osboxes/Activities/TurtleBots.activity/plugins/butia/')

from pybot import usb4butia

asegurarse que dentro del sys.path.insert coloquemos bien la ruta donde se encuentren los plugings del butia

Generamos una instancia de la placa butia

robot = usb4butia.USB4Butia()

Paso 2: Declarar variables

#horas de alimentacion:

hora1= 11

hora2= 21

Horas de alimentación: En este caso declaramos dos horarios de alimentación (se pueden añadir todos los deseados) y nos basamos en que se alimenta puntual en minuto 0 y segundo 0, pero se puede editar haciendo una nueva variable “minuto1” y asignándole un valor, análogo para minuto2, etc.

#distancias

maximadistancia= 50500

distanciaadecuada= 40000

Distancias: En la variable distaciamaxima colocamos el valor que tomamos previamente del sensor cuando queda poca comida (línea más abajo), mientras que en la variable distanciaadecuada colocamos el valor medido de la línea más arriba (cuando consideramos que cargo suficiente comida)

#Posibles estados: abierto, cerrado y sin comida

estado = "cerrado"

Posibles estados: Declaramos la variable estado y le asignamos cerrado que debería ser el estado inicial, suponiendo que el programa empieza a ejecutarse con comida en el alimentador

haycomida= True

Variable haycomida: inicializada en true por la misma suposición anterior

Paso 3: Función alimentar() Análoga a TurtleBots

    def Alimentar():
       robot.set2MotorSpeed(0, 90, 0, 90)
       time.sleep(1.2)
       robot.set2MotorSpeed(0,0, 0, 0)
       time.sleep(0.6)
       robot.set2MotorSpeed(1, 90, 1, 90)
       time.sleep(1.2)
       g = robot.getGray(6)
       while g<=18000:
           robot.set2MotorSpeed(1, 100, 1, 100)
           g= robot.getGray(6)
       robot.set2MotorSpeed(0,0, 0, 0)

Paso 4: Función verificarComida() Análoga a TurtleBots

   def VerificarComida(maximadistancia):
      d = robot.getDistance(5) 
      if d >= maximadistancia:
          global estado
          global haycomida
          estado= "sin comida"
          print "ALERTA: Queda poca comida!!"
          haycomida= False

Paso 4: programa principal

   while True:
       now = datetime.now()
       if estado=="cerrado":
            VerificarComida(maximadistancia)
            if haycomida == True:
                if(now.hour==hora1 or now.hour==hora2) and now.minute == 0 and now.second==0:
                    estado= "abierto"
                    Alimentar()
                b = robot.getButton(4) 
                if (estado == "cerrado" and b==1):
                    estado== "abierto"
                    Alimentar()
        elif estado=="abierto":
             estado= "cerrado"
        elif estado== "sin comida":
             d = robot.getDistance(5) 
             if d <= distanciaadecuada: 
                 estado= "cerrado"
                 haycomida= True

Como podemos ver nuestro programa sigue el diagrama de la maquina de estados, que nos ayudo a organizar mejor el comportamiento de nuestro alimentador Una observación es que en el estado abierto no se hace nada más que cambiar al estado cerrado ya que la función alimentar(), invocada en el estado cerrado, se encarga de cerrar correctamente una vez termina de alimentar. Si no fuera así deberíamos revisar con el sensor de grises que quede bien cerrado antes de cambiar de estado.

Trabajos a futuro

Como se puede ver en los videos a veces las pastillas se trancan y por lo tanto dejan de caer un poco antes de que el alimentador cierre del todo. Esto no es un gran problema ya que como se puede apreciar en el ultimo video, donde se aprieta tres veces el botón, a pesar de trancarse cuando yo vuelvo a alimentar vuelven a salir más pastillas, por lo que sigue funcionando correctamente. Sin embargo este problema ocasiona que caigan distintas cantidades de pastillas cada vez que alimente. Para mejorar el comportamiento del alimentador y solucionar el problema podemos hacer las siguientes mejoras:

1. Colocar otro motor dentro del alimentador para que mueva las pastillas continuamente cuando esta alimentando (y así no se trancan). De esta manera nos aseguramos que sale siempre la misma cantidad de pastillas, pues alimenta siempre en un mismo periodo de tiempo.
2. Observando que el problema se origina porque las pastillas son un poco grandes para la boca del alimentador, otra posible solución es usar un alimentador con boca más grande. Lo complicado es encontrar un objeto más grande reciclado.

Más allá de este punto, otras mejoras al alimentador podrían ser:

1. Uso de materiales más resistentes o rígidos para que la salida de pastillas cuando alimente sea más uniforme.
2. Cables más largos para colocar el botón en un lugar más accesible y tener la libertad de tener la placa y la computadora portátil más lejos.

Autor

Micaela Rodríguez - micaela.rodriguez.dores@fing.edu.uy

Tutores

• Guillermo Trinidad
• Gonzalo Tejera