Robot tè

Robot_tea

Il tè verde e il tè nero hanno temperature e tempi di preparazione diversi, in genere 2 minuti quello verde e 3 quello nero, oltre il gusto diventa amaro, inoltre se si ondeggia la bustina di tè, si migliora il mescolamento, vediamo allora come costruire un robot che prepara il tè al posto nostro.

Robot_tea14

Per fare questo robot servono sostanzialmente un contenitore un po’ alto, (scatola di cioccolatini), un microservo Tower pro 9g sg90 (circa 1 Euro su eBay), un braccetto rigido, una pinzetta (auricolare di un vecchio telefono).

Robot_tea1 Robot_tea2 Robot_tea3 Robot_tea4

Inoltre servono dei pulsanti, un interruttore, un Atmega328p (Arduino su breadboard), spinotti maschio da 3 e da 1 pin (per eventuali future riprogrammazioni), una batteria da 3,6V (telefono), due led, un po’ di cavi, colla a caldo, stagno e un saldatore per saldare e bucare la plastica, i collegamenti sono molto semplici.

Robot_tea13 Robot_tea5 Robot_tea6 Robot_tea7 Robot_tea8

E’ prevista una ricarica tramite un cavetto usb di un vecchio spinotto, da collegare direttamente alla batteria (con la giusta polarità), il circuito di protezione interno si occuperà della sotto e sovracarica.

Robot_tea9 Robot_tea10 Robot_tea19

Ci sono anche due led che indicano il tipo di tè, verde per il tè verde e rosso per il tè nero.

Robot_tea11 Robot_tea12

Ecco il codice:


  #include <Servo.h>                                             //libreria per controllare servomotori
Servo myservo;                                                   //chiamo il servo myservo
unsigned long tempoverde=120000;                                 //tempo tè verde in millisecondi
unsigned long temponero=180000;                                  //tempo tè nero in millisecondi
unsigned long tempoattuale=0;                                    //variabile per memorizzare il tempoattuale
int pos=2070;                                                    //posizione iniziale del servo
int alto=2070;                                                   //altezza massima servo
int basso=1600;                                                  //altezza minima servo
int velox=2;                                                     //velocità servo in millisecondi
int pausa=4000;                                                  //tempo di pausa in immersione in millisecondi
byte pulsanteverde=5;                                            //pulsante verde al pin D5
byte pulsantenero=6;                                             //pulsante nero al pin D6
byte ledverde=3;                                                 //led verde al pin D3
byte lednero=4;                                                  //led nero al pin D4
byte memoverde=0;                                                //memoria verde
byte memonero=0;                                                 //memoria nero

void setup()                                                     //esegue una sola volta all'accensione
{
 pinMode(pulsanteverde,INPUT);                                   //pulsante verde ingresso
 pinMode(pulsantenero,INPUT);                                    //pulsante nero ingresso
 pinMode(ledverde,OUTPUT);                                       //led verde uscita
 pinMode(lednero,OUTPUT);                                        //led nero uscita
 myservo.attach(2);                                              //servo al pin D2
} 

void loop()                                                      //esegue ciclicamente
{ 
 myservo.writeMicroseconds(pos);                                 //muove il servo alla posizione iniziale
 digitalWrite(ledverde,HIGH);                                    //accende led verde
 digitalWrite(lednero,HIGH);                                     //accende led nero
 if((digitalRead(pulsanteverde)==HIGH)&&memoverde==0)            //se il pulsante verde va alto e la memoria verde è 0 
 {
  memoverde=1;                                                   //memoria verde diventa 1
  tempoattuale=millis();                                         //mette in tempoattuale il valore del tempo trascorso dall'inizio fino alla pressione del pulsante 
 }
 if(memoverde==1)                                                //se la memoria verde è 1
 { 
   lampeggiaverde();                                             //esegue la funzione lampeggiaverde
   while((millis()-tempoattuale)<tempoverde)                     //finchè il tempo è minore di 2 minuti
   ondeggia();                                                   //esegue la funzione ondeggia
   memoverde=0;                                                  //resetta memoria verde
 } 

if((digitalRead(pulsantenero)==HIGH)&&memonero==0)               //se il pulsante nero va alto e la memoria nero è 0 
 {
  memonero=1;                                                    //memoria nero diventa 1
  tempoattuale=millis();                                         //mette in tempoattuale il valore del tempo trascorso dall'inizio fino alla pressione del pulsante
 }
 if(memonero==1)                                                 //se la memoria nero è 1
 { 
   lampeggianero();                                              //esegue la funzione lampeggianero
   while((millis()-tempoattuale)<temponero)                      //finchè il tempo è minore di 3 minuti
   ondeggia();                                                   //esegue la funzione ondeggia
   memonero=0;                                                   //resetta memoria nero
 }
}

void lampeggiaverde()                                            //funzione lampeggiaverde
{
  digitalWrite(lednero,LOW);                                     //spegne il led nero
  digitalWrite(ledverde,HIGH);                                   //accende il led verde
  delay(1000);                                                   //aspetta 1 secondo
  digitalWrite(ledverde,LOW);                                    //spegne il led verde
  delay(1000);                                                   //aspetta 1 secondo
  digitalWrite(ledverde,HIGH);                                   //accende il led verde
  delay(1000);                                                   //aspetta 1 secondo
  digitalWrite(ledverde,LOW);                                    //spegne il led verde
  delay(1000);                                                   //aspetta 1 secondo
 }

 void lampeggianero()                                            //funzione lampeggianero
{
  digitalWrite(ledverde,LOW);                                    //spegne il led verde
  digitalWrite(lednero,HIGH);                                    //accende il led nero
  delay(1000);                                                   //aspetta 1 secondo
  digitalWrite(lednero,LOW);                                     //spegne il led nero
  delay(1000);                                                   //aspetta 1 secondo
  digitalWrite(lednero,HIGH);                                    //accende il led nero
  delay(1000);                                                   //aspetta 1 secondo
  digitalWrite(lednero,LOW);                                     //spegne il led nero
  delay(1000);                                                   //aspetta 1 secondo
 }

void ondeggia()                                                  //funzione ondeggia
{
  for(pos=alto; pos>=basso; pos--)                               //esegue ciclicamente da alto a basso e ad ogni ciclo decrementa di 1
  {                                
  myservo.writeMicroseconds(pos);                                //muove il servo alla posizione attuale
  delay(velox);                                                  //aspetta 2 millisecondi
  }
  delay(pausa);                                                  //aspetta 4 secondi
  for(pos=basso; pos<=alto; pos++)                               //esegue ciclicamente da basso a alto e ad ogni ciclo incrementa di 1
  {                                 
  myservo.writeMicroseconds(pos);                                //muove il servo alla posizione attuale
  delay(velox);                                                  //aspetta 2 millisecondi
  } 
}

  

Nel codice ci sono degli unsigned long per tenere i tempi in millisecondi dei tè quindi 2 e 3 minuti ed una variabile tempoattuale che si aggiorna alla pressione di uno dei due pulsanti, altrimenti millis() comincierebbe a contare a partire dall’accensione del dispositivo, non si sono usate somme di delay perchè risultavano tempi poco precisi.

E’ possibile modificare il comportamento del robot cambiando alcuni parametri, alto è l’altezza massima, basso quella minima, velox è la velocità in ms del servo (per velocità maggiori si può usare delayMicroseconds in µs al posto di delay in ms) e pausa è il tempo di immersione in ms.

Il funzionamento è il seguente: all’inizio (dopo l’attivazione dell’interruttore) si accendono i due led per indicare i colori del tè da scegliere, non appena si preme un pulsante, parte il conteggio, il rispettivo led lampeggia e una memoria passa a livello alto, a quel punto viene eseguita la funzione ondeggiamento (che usa writeMicroseconds che può variare da 500 a 2500 µs con precisione di 1µs cioè 0,09 gradi), superato un certo tempo il programma esce dal while e non ondeggia più, poi viene posta a 0 la rispettiva memoria in modo da poter ricominciare un nuovo ciclo.

Il microprocessore può eseguire solo operazioni sequenziali quindi mentre fa il tè verde, se si premesse il pulsante del tè nero, non succederebbe nulla, il consumo totale è di circa 13mA da fermo, circa 6mA solo il servo da fermo, qualche decina di milliampere in movimento.

Robot_tea15 Robot_tea16 Robot_tea17 Robot_tea18

Supponendo una batteria da 1Ah e un consumo medio di 4/5h*0,013A da fermo e 1/5h*0,03A in movimento avremo un consumo energetico di circa 7mAh, quindi 6 giorni di fila, oppue 3/60*7mAh=0,35mAh ogni tè nero, quindi 1000/0,35=2857 tè neri, con una ricarica di circa 2ore, un saluto e alla prossima.

Precedente Modificare un portalampada pir Successivo Pescatore automatico Metin2