Coctelera Arduino -Coctail Machine

Coctelera Arduino- Cocktail Machine 

Grupo 1

Miembros del grupo:

Pablo Pérez Martínez
Adrián Suárez Parra
Íker Riquelme Rolando
Gabriel Leal Gavarrón

Enlaces

https://www.dropbox.com/s/a3fwvwavnr86h4d/COCKTAIL%20MACHINE.pptx?dl=0



Introducción

Con este proyecto nos introducimos y familiarizamos con el
mundo hardware controlado desde software. En nuestro caso, con la elaboración
de una “cocktail machine” que en la propuesta del proyecto tenía un dispensador
de hielo, los grifos, la pantalla LCD para comunicar en qué estado estaba y un
dispositivo bluetooth con el que recibiría las órdenes.
A lo largo de la memoria, comentaremos como fue el
desarrollo del proyecto, los problemas encontrados y cuáles podrían ser
posibles mejoras a este, aparte de adjuntar el código y los esquemas del mismo.

Esquema
hardware-software

Esquema software

Esquema Hardware

Esquema motor paso a paso:
Esquema pantalla LCD:

Esquema Módulo Bluetooth:
Esquema global:





Componentes y
precios

Componente
Precio
Cantidad
Total
Transformador
11
1
11
Driver
5
2
10
Bluetooth
16,5
1
16,5
MOTOR PASO A PASO CON TORNILLO
70,41
1
70,41
Acoplador para motores
7
2
14
Pegamento Soldador
3,9
1
3,9
Soporte Botellas
45,33
1
45,33
Pilas
5,7
1
5,7
Botellas
0
6
0
Maderas
0
1
0
Vaso
0
1
0
LCD
0
1
0
Motor bipolar
23
1
23
Cables
9
1
9
208,84





Problemas y soluciones


 Los problemas se detallan con fotografías en la memoria:

Problema 1

El primer problema que nos encontramos, era girar los grifos. La
solución que planteamos fue construir una estructura a nuestra coctelera para
poder colocar el motor arriba y facilitar la forma de girar los grifos.

Problema 2

El motor tenía una varilla demasiado corta
como para conseguir que girara los grifos de manera cómoda. Por lo que
estuvimos buscando un “acoplador para motor paso a paso” que nos sirvió para
alargar la varilla del motor y facilitar el giro.
Al principio, mientras lo buscábamos (que fue
bastante tedioso) hicimos una pieza provisional para hacer pruebas
Posteriormente, compramos el acoplador e
incorporamos el motor a la coctelera

Problema 3

El tercer problema que surgió fue:
-Cómo presionar los grifos
-Con qué presionar los grifos
-Cómo levantar el objeto con el que íbamos a
presionar
La solución fue comprar un motor de eje
roscado, el cual tenía la suficiente fuerza para subir un objeto (a diseñar en
ese momento) que presionara el grifo. Pensamos que lo más cómodo sería que ese
motor subiera una plataforma con un agujero en el extremo para que presionara
el grifo y al mismo tiempo permitiera que el líquido cayera en el vaso que
pondríamos en la parte inferior.

Problema 4

Aunque la plataforma ya subía, otro de los
problemas fue, que por el coste de los grifos, estos eran bastante malos y
estaban bastante duros para presionarlos incluso con la mano. Por lo que,
tuvimos que abrir grifo a grifo y cortar los muelles para que fuera más fácil
presionarlos.

Problema 5

Al recortar los muelles de los grifos, la
estructura que impedía que saliera más líquido de la botella mientras el líquido
estaba pulsado, era inservible e impedía en algunos casos la salida de líquido,
por lo que tuvimos que quitarla.

Problema 6

Nuestro proyecto consumía demasiado voltaje y
al agotarse, los motores funcionaban peor, por lo que empezamos a pensar
métodos alternativos a las pilas. Nuestra idea fue un conversor de 220V a 12V
el cual podríamos conectar a la red eléctrica y de este modo suministrar
constantemente el voltaje necesario sin variación.
 

Problema 7

Al implementar los dos motores en un programa
único, el voltaje no llegaba bien a uno de los dos motores y este no funcionaba
correctamente. Al conectarlo en serie, el voltaje se distribuía y hacía que
solo funcionara un motor. Al conectarlo en paralelo, el voltaje se distribuía
pero la corriente era insuficiente, por lo que no se movían correctamente.
Finalmente, lo que hicimos fue implementar en
el código la función digitalWrite(); para inhabilitar los pines del motor que
no íbamos a utilizar, de este modo, el voltaje y corriente llegaban integros
únicamente al motor que si estábamos utilizando en ese momento.
El código se adjunta como apéndice.

Problema 8

Al incorporar los dos motores, el dispositivo
bluetooth, la pantalla LED, el transformador, potenciómetro,… El circuito era
bastante caótico y la estética era bastante mala, por lo que añadimos a nuestra
estructura inicial un pequeño armario con una balda para poder distribuir los
circuitos de manera más cómoda. De este modo, los circuitos quedaban ocultos a
la vista de los usuarios pero estaba más distribuido y seguía siendo
manipulable en caso de que fuera necesario. Le añadimos una puerta de cristal
para que el circuito quedara visible por si era necesario.

Problema 9

El giro del grifo no era preciso, ya que
influía mucho el peso que tenía, asi que tuvimos que suministrar a cada botella
un peso fijo y también unos pasos individuales por cada botella, lo que
dificultaba mucho el código.
Lo que hicimos fue ponerle menos velocidad al
motor paso a paso y de este modo sí que encontramos una forma precisa de girar
los grifos.
El código se adjunta en el apéndice de la
práctica.

Problema 10

Algunos grifos, por razones que no nos
explicamos gotean, incluso cuando no está la apertura de líquido abierta. Puede
que hayamos dañado la estructura troncal y permita una breve salida de líquido
o que se quede este retenido en la estructura aun habiendo cerrado el grifo. El
goteo se produce rara vez, por lo que no hemos puesto hincapié en solucionarlo,
ya que no es ni escandaloso ni constante.

Problema 11

El motor de eje roscado, al tener tanta
fuerza, se levantaba cuando tenía que presionar los grifos, por lo que tuvimos
que sujetarlo a la base con dos escuadras.

Problema 12

Al levantar nuestra pieza, esta giraba en
algunas ocasiones, por lo que tuvimos que colocarle una guía que subiera recta.
Aun así, al presionar el grifo se seguía doblando porque la parte trasera
pesaba muy poco, por lo que tuvimos que ponerle un peso y una goma como
“tensor” para que pudiera presionar bien los grifos.

Problema 13

Nos faltaban pines, asi que aprovechamos los
pines analógicos como digitales para poner la LCD mediante el método
analogWrite(pin,255)
 

Problema 14

Incorporamos una estructura metálica alrededor de la
pantalla LCD, pero tuvimos que quitarla ya que hacía que la pantalla tuviera un
comportamiento extraño.



Trabajo de cada miembro del grupo


                Quienes
han participado (Verde)

                Quién
no ha participado (Azul)
Adrián Suárez Parra
Gabriel Leal Gavarrón
Pablo Pérez Martínez
Íker Riquelme Rolando
Elaboración de la estructura
Elaboración del código
Aplicación Android
Solución a problemas

Resultado final y mejoras

 
El resultado final es este, está muy cerca del resultado
esperado:

Las mejoras que se podrían añadir serían:
         
Que los materiales fueran metálicos y no de
madera
         
Que se utilizara más peso en la parte trasera de
la pieza elevadora
         
Que se taparan los cables de la pantalla LCD sin
que interfiera en su funcionamiento
         
Incorporación de dispensador de hielo



Código Arduino

#include <Stepper.h>
#include <LiquidCrystal.h>
#include <SoftwareSerial.h>
SoftwareSerial BT1(3,2); // Bluetooth
LiquidCrystal lcd(A0, A1, A2, A3, A4 , A5); //LCD analógico
int s =0; // variable para bluetooth
int encontrado=0;
const int stepsPerRevolution=200;

Stepper motorGirar (stepsPerRevolution, 8,9,10,11);  //motor Paso a paso girar
Stepper motorLevantar (stepsPerRevolution, 4,5,6,7);      //motor Paso a paso Levantar
     
 double unaBotella=33.5; // pasos para girar una botella
 double pasosActual=0;
 double ron=0;
 double wisky=ron+unaBotella;
 double cocacola=wisky+unaBotella;
 double fanta=cocacola+unaBotella;
 double vodka=fanta+unaBotella;
 double sprite=vodka+unaBotella;
 double total=6*unaBotella;

void setup() {

  BT1.begin(9600);
  inicializarLCD();
  motorGirar.setSpeed(3); // inicializamos la velocidad del motor de giro a 3 rpm
  motorLevantar.setSpeed(120);// inicializamos la velocidad del motor de giro a 120 rpm

for(int i=4; i<=11;i++){
pinMode(i,OUTPUT);
digitalWrite(i, LOW);
}

}

void ponerALow(int a,int b, int c, int d){
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  }
void ponerAHigh(int a,int b, int c, int d){
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  }

////////////////////////////////////////////////
//Cócteles Posibles
//Cubata ron cocacola
//Whisk-cola
//Malibu and cola (lima cola y ron)
//Gimlet vodka-Lima -sprite
//Johnny Cool whisky- Lima -sprite
//Daiquiri Ron-lima-sprite(para rellenar mas)
//Absolute pop (vodka cocacola)

 double absolutePop(double pasosActual){
  pasosActual=echarVodka(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  pasosActual=echarVodka(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  pasosActual=echarVodka(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  return pasosActual;
  }
  double cubata(double pasosActual){
  pasosActual=echarRon(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  pasosActual=echarRon(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  pasosActual=echarRon(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  return pasosActual;
  }
   double daiquiri(double pasosActual){
  pasosActual=echarRon(pasosActual);
  pasosActual=echarSprite(pasosActual);
  pasosActual=echarFanta(pasosActual);
  pasosActual=echarRon(pasosActual);
   pasosActual=echarFanta(pasosActual);
  pasosActual=echarSprite(pasosActual);
  return pasosActual;
  }

   double johnyCool(double pasosActual){
  pasosActual=echarWisky(pasosActual);
  pasosActual=echarSprite(pasosActual);
  pasosActual=echarFanta(pasosActual);
  pasosActual=echarWisky(pasosActual);
   pasosActual=echarFanta(pasosActual);
  pasosActual=echarSprite(pasosActual);
  return pasosActual;
  }

  double gimlet(double pasosActual){
  pasosActual=echarVodka(pasosActual);
  pasosActual=echarSprite(pasosActual);
  pasosActual=echarFanta(pasosActual);
  pasosActual=echarVodka(pasosActual);
   pasosActual=echarFanta(pasosActual);
  pasosActual=echarSprite(pasosActual);
  return pasosActual;
  }

  double malibuLima(double pasosActual){
  pasosActual=echarRon(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  pasosActual=echarFanta(pasosActual);
  pasosActual=echarCocacola(pasosActual);
   pasosActual=echarFanta(pasosActual);
  pasosActual=echarRon(pasosActual);
  return pasosActual;
  }

  double wiskola(double pasosActual){
  pasosActual=echarWisky(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  pasosActual=echarWisky(pasosActual);
  pasosActual=echarCocacola(pasosActual);
   pasosActual=echarWisky(pasosActual);
  pasosActual=echarCocacola(pasosActual);
  return pasosActual;
  }
////////////////////////////////////////////////////////
//FIN cocteles posibles//

////////////////////////////////////////////////////////
//Calculo de Giros para echar bebidas//
double echarRon(double pasosActual){
  lcd.clear();
  lcd.write(“Sirviendo       “);
  lcd.setCursor(0,1);
  lcd.write(“ron”);
  if(pasosActual<=fanta){
  motorGirar.step(-pasosActual);
  pasosActual=0;
  delay(1000);
  echar();
  }
else if(pasosActual>fanta){
  double pasos=total-pasosActual;
   motorGirar.step(pasos);
   delay(1000);
   pasosActual=0;
   echar();

  }
 return pasosActual;
  }

double echarWisky(double pasosActual){
  lcd.clear();
  lcd.write(“Sirviendo”);
    lcd.setCursor(0,1);
  lcd.write(“whisky”);
  if((pasosActual<=vodka)&&(pasosActual>=wisky)){
  double pasos = pasosActual-wisky;
  motorGirar.step(-pasos);
  pasosActual=wisky;
  delay(1000);
  echar();
  }
else if(pasosActual>vodka){
  double pasos=unaBotella*2;
   motorGirar.step(pasos);
   delay(1000);
   pasosActual=wisky;
   echar();
  }
else if(pasosActual<wisky){
   double pasos=unaBotella;
   motorGirar.step(pasos);
   delay(1000);
   pasosActual=wisky;
   echar();
  }
  return pasosActual;
  }

double echarCocacola(double pasosActual){
  lcd.clear();
  lcd.write(“Sirviendo”);
    lcd.setCursor(0,1);
  lcd.write(“Coca-cola”);
  if((pasosActual<=sprite)&&(pasosActual>=cocacola)){
  double pasos = pasosActual-cocacola;
  motorGirar.step(-pasos);
  pasosActual=cocacola;
  delay(1000);
  echar();
  }
else if(pasosActual<cocacola){
  double pasos=cocacola -pasosActual;
   motorGirar.step(pasos);
   delay(1000);
   pasosActual=cocacola;
   echar();

  }
  return pasosActual;
  }

double echarFanta(double pasosActual){
  lcd.clear();
  lcd.write(“Sirviendo”);
    lcd.setCursor(0,1);
  lcd.write(“fanta”);
  if((pasosActual<=sprite)&&(pasosActual>=fanta)){
  double pasos = pasosActual-fanta;
  motorGirar.step(-pasos);
  pasosActual=fanta;
  delay(1000);
  echar();
  }
else if(pasosActual<fanta){
  double pasos=fanta -pasosActual;
   motorGirar.step(pasos);
   delay(1000);
   pasosActual=fanta;
   echar();
  }
  return pasosActual;
  }

double echarVodka(double pasosActual){
  lcd.clear();
  lcd.write(“Sirviendo”);
   lcd.setCursor(0,1);
  lcd.write(“vodka”);
  if((pasosActual<=vodka)&&(pasosActual>=wisky)){
  double pasos = vodka-pasosActual;
  motorGirar.step(pasos);
  pasosActual=vodka;
  delay(1000);
  echar();
  }
else if(pasosActual>vodka){
  double pasos=unaBotella;
   motorGirar.step(-pasos);
   delay(1000);
   pasosActual=vodka;
   echar();
  }
else if(pasosActual<wisky){
   double pasos=unaBotella*2;
   motorGirar.step(-pasos);
   delay(1000);
   pasosActual=vodka;
   echar();
  }

  return pasosActual;
  }

double echarSprite(double pasosActual){
  lcd.clear();
  lcd.write(“Sirviendo”);
   lcd.setCursor(0,1);
  lcd.write(“sprite”);
  if((pasosActual<=sprite)&&(pasosActual>=cocacola)){
  double pasos =sprite- pasosActual;
  motorGirar.step(pasos);
  pasosActual=sprite;
  delay(1000);
  echar();
  }
else if(pasosActual<cocacola){
  double pasos=pasosActual;
   motorGirar.step(-pasos);
   delay(1000);
   pasosActual=sprite;
   echar();
  }

  return pasosActual;
  }
//FIN CALCULO GIROS//
//////////////////////////////////////////

////////////////////////////
//ECHAR LÍQUIDO
void echar(){
      delay(500);
      ponerALow(8,9,10,11); //Desactivamos motor girar
      ponerAHigh(4,5,6,7);  // Activamos motor Levantar
   
      motorLevantar.step(1500);
      delay(500); // variar para más mililitros
      motorLevantar.step(-1200);
   
      ponerALow(4,5,6,7); //Desactivamos motor Levantar
      ponerAHigh(8,9,10,11); // Avtivamos motor Girar
  }

////////////////////////////
//FIN ECHAR LÍQUIDO

////////////////////////////
//Inicializar LCD
void inicializarLCD(){

  pinMode(A0,OUTPUT);
  pinMode(A1,OUTPUT);
  pinMode(A2,OUTPUT);
  pinMode(A3,OUTPUT);
  pinMode(A4,OUTPUT);
  pinMode(A5,OUTPUT);
  analogWrite(A0,255);
  analogWrite(A1,255);
  analogWrite(A2,255);
  analogWrite(A3,255);
  analogWrite(A4,255);
  analogWrite(A5,255);
  lcd.begin(16, 2);
  lcd.write(“Bienvenido”);

  }

//FIN INICIALIZAR LCD
////////////////////////////

////////////////////////
//BUCLE
void loop() {
    if (BT1.available()){
            if(encontrado==0){
            s = BT1.read();  //LLegará mientras no haya encontrado un coctel.
                             // Y buscará cuál debe servir en los siguientes if
            if(s==49){ //1 en ascii
            encontrado=1;
             lcd.clear();
             lcd.write(“Seleccionado”);
             lcd.setCursor(0,1);
             lcd.write(“cubata”);
             delay(2000);
            pasosActual=cubata(pasosActual);
            delay(10000);
            }
            else if(s==50){
            encontrado=1;
             lcd.clear();
             lcd.write(“Seleccionado”);
             lcd.setCursor(0,1);
             lcd.write(“Whiskola”);
             delay(2000);
            pasosActual=wiskola(pasosActual);
            delay(10000);
            }
             else if(s==51){
            encontrado=1;
             lcd.clear();
             lcd.write(“Seleccionado”);
             lcd.setCursor(0,1);
             lcd.write(“Malibu-Lima”);
              delay(2000);
            pasosActual=malibuLima(pasosActual);
            delay(10000);
            }
             else if(s==52){
            encontrado=1;
             lcd.clear();
             lcd.write(“Seleccionado”);
             lcd.setCursor(0,1);
             lcd.write(“Gimlet”);
              delay(2000);
            pasosActual=gimlet(pasosActual);
            delay(10000);
            }
             else if(s==53){
            encontrado=1;
             lcd.clear();
             lcd.write(“Seleccionado”);
             lcd.setCursor(0,1);
             lcd.write(“JohnyCool”);
              delay(2000);
            pasosActual=johnyCool(pasosActual);
            delay(10000);
            }
             else if(s==54){
            encontrado=1;
             lcd.clear();
             lcd.write(“Seleccionado”);
             lcd.setCursor(0,1);
             lcd.write(“Daiquiri”);
              delay(2000);
            pasosActual=daiquiri(pasosActual);
            delay(10000);
            }
             else if(s==55){
            encontrado=1;
             lcd.clear();
             lcd.write(“Seleccionado”);
             lcd.setCursor(0,1);
             lcd.write(“Absolute Pop”);
              delay(2000);
            pasosActual=absolutePop(pasosActual);
            delay(10000);
            }
            }
       
         
            }
   if(encontrado==1){
    lcd.clear();
    lcd.write(“Coctel”);
    lcd.setCursor(0,1);
    lcd.write(“finalizado”);
     encontrado=0;
     delay(1000);

    lcd.clear();
    lcd.write(“Esperando pedido”);
    }

}

Bibliografía

También te podría gustar...

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *