Ver el código de «Alimentador automático para macotas»

[[Archivo:Presentacion.jpg|200px]]

== 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.

[[Archivo:Plat.png]]

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

[[Archivo:c1.jpg|300px]]



'''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:


[[Archivo:c2.jpg|300px]]


'''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:


[[Archivo:c3.jpg|300px]]


'''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. 

[[Archivo:c4.jpg|300px]]

'''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. 


[[Archivo:c5.jpg|300px]]

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.
Luego 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.

[[Archivo:c6.jpg|300px]]





'''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. Luego 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:

[[Archivo:c7.jpg|300px]] [[Archivo:c8.jpg|300px]]

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 en sentido vertical en los siguientes pasos) más 2 centímetros.
Se recomienda que sea en una esquina.

[[Archivo:c9.jpg|300px]]



'''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 en sentido vertical contra la pared, junto a donde esta el alimentador.

[[Archivo:c10.jpg|300px]]


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. 

[[Archivo:c11.jpg|300px]]



'''Paso 10:''' 
Atar la estructura que tiene a la placa al costado del bidón y asegurarse que quede bien sujeta.

Aclaración: 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.

[[Archivo:c12.jpg|300px]]



'''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!

[[Archivo:c13.jpg|300px]]
[[Archivo:c14.jpg|300px]]
[[Archivo:c15.jpg|300px]]

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

[[Archivo:c16.jpg|300px]]


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.

[[Archivo:c17.jpg|300px]]

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.

[[Archivo:c18.jpg|300px]] [[Archivo:c19.jpg|300px]]

'''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.

[[Archivo:c20.jpg|300px]]

==Planificación del código ==
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 Python, 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.

[[Archivo:t1.png|300px]]


'''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).

[[Archivo:t2.png|300px]]

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) .

[[Archivo:t3.png|300px]] [[Archivo:t4.png|300px]]

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.
Además 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:'''

[[Archivo:t5.png|300px]]

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.



[[Archivo:maquina.png|600px]]


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


'''Paso 1:''' Importar librerías

Librerias de manejo del tiempo:

<code>
import time

import datetime

from datetime import datetime
</code>

Libreria sys y Pybot necesarias para el butia:

<code>
import sys

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

from pybot import usb4butia
</code>

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:

<code>
robot = usb4butia.USB4Butia()
</code>


'''Paso 2''': Declarar variables

<code>
<nowiki>#</nowiki>horas de alimentacion:

hora1= 11

hora2= 21
</code>


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.


<code>
<nowiki>#</nowiki>distancias 

maximadistancia= 50500 

distanciaadecuada= 40000
</code>


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).




<code>
<nowiki>#</nowiki>Posibles estados: abierto, cerrado y sin comida

estado = "cerrado"
</code>

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.



<code>
haycomida= True
</code>

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.

== Pruebas ==

=== Alimentando en la hora correspondiente ===

<youtube>https://youtu.be/eSAJmQF-Yqk </youtube>

=== Alimentando aprentando el botón ===

<youtube> https://youtu.be/BEU6HuE0KH4 </youtube>

===  ¿Qué pasa si hay poca comida? ===

<youtube> https://youtu.be/Z4-NmrpfEsk </youtube>

=== Apretando el botón tres veces ===

<youtube> https://youtu.be/-BgXIoUxWvg </youtube>

== Trabajo 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: 

# 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.
# 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:

#Uso de materiales más resistentes o rígidos para que la salida de pastillas cuando alimente sea más uniforme.
#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 - [mailto://micaela.rodriguez.dores@fing.edu.uy micaela.rodriguez.dores@fing.edu.uy]

== Tutores ==
*Guillermo Trinidad
*Gonzalo Tejera