TraktoBot, Bluetooth bidez kontrolatutako traktorea

TraktoBot, Bluetooth bidez kontrolatutako traktorea

TRAKTOBOT
.
Gure proiektua bluetooth bidez konektatutako traktorean oinarritzen da, eta bluetooth teknologiarekin sekuentzien aldaketa egitea ahalbidetezen du gure mugikorraren bitartez, guk nahi duguna egin dezan traktoreak.
.
.
     Proiektu honek dituen teknologiak:
.
1-Bluetooth: dispositibo inalambriko bat da, non mugikorrarekin konektatzean mikrokontroladoreari mugikorraren bitartez aginduak bidaltzea ahalbidetzen digu. Hau bluecontrol aplikazioaren bitartez kontrola dezakegu, eta aplikazio hau play-estoretik deskargatu daiteke.
.

.
2-L293D: Teknologia honen bitartez, motorren kontrola lortzen dugu, bi aldetara bira dezaketelako. Txip honek 2 motor kontrola ditzazke gehienez, bainan beti ahal izango diozu txertatu besteren bat beste bi motor erabiltzeko.
Proiektuaren funtzionamendua:
     Bluetooth-aren bitartez komando bat  sartuko diogu gure mikrokontroladoreari, eta honek komando bat ala beste jasotzean mikrokontroladoreari barneratutako programaren sekuentzi bat edo beste martxan jartzen da. 5 sekuentzi modu egin ditugu, lehenengoa aurreraka joateko, bigarrena atzeraka joateko, hirugarrena ezkerrera biratzeko, laugarrena eskuinera biratzeko, eta bostgarrena eta azkena motorrak geldi geratzeko.
Proiektua aurrera eramateko pausuak:
.
1-Eskemaren edizioa:
.
     Lehenik eta behin proteus programaren isis atalean eskema bat egitea beharrezkoa da, gure plakan beharrezkoak diren elementuekin, funtzionamendua bermatzeko eta sortutako programarekin simulazioari ekiditeko. Isisa eginda eduki ondoren, hau modifikatu egingo dugu Ares-a sortzeko, eta hau sortu ondoren hurrengo atalera pasatzen gera.
..

     Bigarren hau ares-a egiteko da, eraldatuta:
.
.
2- PCB-aren fabrikazioa:
.
     Issis eko eskema aresera pasa eta pistak eraiki ondoren, LPKF makinara goaz guk egindako plaka imprimatzeko. Hau ongi egiteko, aresean gerberrak sortu behar dira, eta LYT-arekin, boar master programan .lmd duen beste bat lortuko dugu, eta honekin LPKF-ak ulertu dezan bere lanarekin hasteko.
.
.
     -Hau da lpkf-arentzat egindako ares-a.
.
.
3-Konponenteak plakan jartzea:
.

     Plaka ondo eginda dagoela zihurtatu ondoren, hautatutako konponenteak plakan soldatzen jarri ginen, kontuan hartzen bakoitzaren posizioa eta bakoitzaren kokalekua. Hau egiteko dexente denbora tardatu genuen, plakan soldatzeko eremuak ez baitziren guztiz guk esperotakoak, baino lortu genuen ongi soldatzea.

.

.

4- Pic-aren programazioa:
.
Komentarioekin dator, eta hauek gazteleraz daude denek ulertzeko zer egiten duen programaren zati bakoitzak.

/*——————————————-*\

 | proyecto del control de tractor: Iñigo Lazkano

 el programa consiste en controlar un tractor desde el dispositivo android.

\*——————————————-*/

#include <16f87.h>

#FUSES NOWDT                    //No Watch Dog Timer

#FUSES INTRC_IO                 //Internal RC Osc, no CLKOUT

#FUSES PUT                      //Power Up Timer

//#FUSES MCLR                     //Master Clear pin enabled

#FUSES NOBROWNOUT               //No brownout reset

#FUSES NOCPD                    //No EE protection

#FUSES NOWRT                    //Program memory not write protected

#FUSES NODEBUG                  //No Debug mode for ICD

#FUSES NOPROTECT                //Code not protected from reading

#FUSES NOFCMEN                  //Fail-safe clock monitor disabled

#FUSES NOIESO                   //Internal External Switch Over mode disabled

#use delay(clock=4000000)

#use RS232(baud=9600, xmit=PIN_B5, rcv=PIN_B2)      //#use rs232(baud=9600,parity=N,xmit=PIN_A3,rcv=PIN_A2,bits=8)

#use i2c(Master,sda=PIN_B1,scl=PIN_B4)

int8 sekuentzia=’E’;                                                          //declaramos que para empzar esten los motores apagados

void serie(void);

/****************************************************************************

      FUNCION PRINCIPAL

****************************************************************************/

void main(void)

{

   int8 i;

   setup_adc_ports(NO_ANALOGS);                              // para que los puertos sean digitales

   set_tris_b(0b00000100);

//   set_tris_a(0xff);

  

  

     

   while(1)

   {  

      serie();                                                                        //leer bluetooth

      if(sekuentzia==’E’)                                                     //si esta detectando una E entra en este ciclo

      {

         while(sekuentzia==’E’)                                                               

         {

               output_low(PIN_B0),output_low(PIN_B3),output_low(PIN_B1),output_low(PIN_B4);  //parar los motores

               serie();                                                               //lee la entrada del bloetooth

               if(sekuentzia!=’E’)                                             //si lo que lee es diferente a E

                  break;                                                              //sal del ciclo

         }

      }

      else if(sekuentzia==’B’)

      {

         while(sekuentzia==’B’)                                         //Si lee un B entra en este ciclo

         {

               output_low(PIN_B0),output_low(PIN_B3),output_high(PIN_B1),output_high(PIN_B4);//Motores hacia atras

               serie();                                                                //lee la entrada del bloetooth

               if(sekuentzia!=’B’)                                             //si canbia de valor la entrada

                  break;                                                              //sal del ciclo

         }

      }  

      else if(sekuentzia==’C’)                                              //Si lee un C entra en este ciclo

      {

         while(sekuentzia==’C’)

         {

           output_high(PIN_B0),output_low(PIN_B3),output_low(PIN_B1),output_low(PIN_B4);     //girar izquierda

            serie();                                                                   //lee la entrada del bloetooth

            if(sekuentzia!=’C’)                                                 //si canbia de valor la entrada

               break;                                                                  //sal del ciclo

         }

      }  //fin else if sek C

       else if(sekuentzia==’D’)                                              //Si lee un D entra en este ciclo

      {

         while(sekuentzia==’D’)

         {

               output_low(PIN_B0),output_high(PIN_B3),output_low(PIN_B1),output_low(PIN_B4); //girar derecha

               serie();                                                                 //lee la entrada del bloetooth

               if(sekuentzia!=’D’)                                               //si canbia de valor la entrada

                  break;                                                                //sal del ciclo

         }

      }

        else if(sekuentzia==’A’)                                              //Si lee un A entra en este ciclo

      {

         while(sekuentzia==’A’)

         {

               output_high(PIN_B0),output_high(PIN_B3),output_low(PIN_B1),output_low(PIN_B4);//Motores                                                                                                                                hacia delante

               serie();                                                                  //lee la entrada del bloetooth

               if(sekuentzia!=’A’)                                               //si canbia de valor la entrada

                  break;                                                                //sal del ciclo

         }

      }

   }                                                                                       //fin while 1

}                                                                                          //fin main

/****************************************************************************

      FUNCION Serie

****************************************************************************/

void serie(void)

{

   if(kbhit() !=0)                                                                            //si canbia la entrada del bloetooth,

   {

      sekuentzia=getc();                                                                    //guarda lo que recibas en la variable llamado sekuentzia

   }  

}

5- Sekuentziak:

.

Hemen ikus daiteken moduan, pin bakoitza zein egoeratan egon behar den momentu bakoitzean adierazten digu.
Sekuentzia A: bi motoreak aurreraka.
Sekuentzia B: bi motoreak atzeraka.
Sekuentzia C: ezkerreko motorea martxan eta eskuinekoa geldirik.
Sekuentzia D: eskuineko motorea martxan eta ezkerrekoa geldirik.
Sekuentzia E: bi motoreak geldirik.

 

6-Bluecontrol aplikazioa:
.

    Edozein mugikorretan aplikazio hau instalatzean bluetooth-a kontrola dezakezu,baina mugikor batekin konektatuta dagoenean ezin da beste gailuren batekin konektatu. honekin, denbora errealean guk aplikatu nahieko sekuentzia aukeratzean datza.

7- -Prototipoa eraikitzea

.
Plastikozko piezekin sorturiko traktorea da, ABS edo PLA materialak erabili daitezke.Plastikozko piezak eraikitzeari ekin genion, 3D-ko impresoran erraza baizen piezak egitea. Hontaz gain, plastikozko piezak pisu gutxikoak eta arinak dira, eta traktorearen estrukturarako gogorrak ziren.3D-ko imprimagailuak, donbosko ikastolakoak erabili ditugu.
.
     Honako piezak atera dira:
.
.
.

8- -dena kableatzea:
.

     Hau da azken atala, eta plaka basetik motorretara dijoazen kableak eraikitzean datza. Horretarako, kontuan hartu behar da nora dijoan irteera bakoitzeko seinalea, gaizki eraman ezkero beste motore bat piztuko baita.
.
.
Erabilitako materiala
-Pic 16f87 (1)
-L293D (1)
-RES 10k (1)
-Condensador 220nf (1)
-Condensador 27pf (2)
-Cristal de cuarzo (1)
-Bluetooth (1)

-TT-motor (2)

Proiektua egiteko behar dituzuen artxiboak hemendik deskarga ditzakezue.

Robot «Cuadrúpedo AI» controlado por Android

Robot «Cuadrúpedo AI» controlado por Android

¿Que es un robot?

Un robot es un dispositivo electrónico y generalmente mecánico capaz de desempeñar tareas automáticamente, ya sea por medio de supervisión humana directa, a través de un programa predefinido o siguiendo un conjunto de reglas generales establecidas. Existen multitud de robots diseñados para cumplir diferentes objetivos: como brazos robóticos para el montaje de piezas en una fábrica, vehículos aéreos no tripulados o los robots móviles terrestres.

El “cuadrúpedo AI” nace de la idea de dos alumnos con ganas de hacer un proyecto visual, no nos valía un proyecto estanco, que no se moviese, que no llamase la atención, y ahí, aparece el Cuadrúpedo.

El robot esta construido con piezas de plástico, ABS o PLA. Nos decantamos por las piezas de plástico por la sencillez que nos ofrecían las impresoras 3D para crear piezas. Aparte las piezas de plástico son de gran ligereza y lo suficientemente robustas para la estructura del cuadrúpedo. Las piezas de plástico están impresas en las impresoras 3D del ikaslab, gracias a Tumaker.

Las uniones son los servos FUTABA S3003. Estos servos únicamente tienen tres conexiones, alimentación (5v) , masa y control Estos van unidos a las piezas de plástico con tornillos como se puede ver en la siguiente imagen:

Para las patas se corto goma con intención de que no se resbalase por el pavimento, sin esa goma el movimiento del cuadrúpedo habría quedado mermado en exceso. Al principio tuvimos problemas con esto, pensamos que sin goma los movimientos serian naturales y andaría normal, pero resulto que no, se resbalaba y se quedaba en el sitio sin avanzar. Para ello cortamos un trozo de goma y lo pegamos con loctite al ABS de la pata.

Una vez recopiladas todas las piezas el robot queda montado tal que así, únicamente el chasis sin nada de electrónica.

Mientras uno de los componentes del equipo iba montando el esqueleto del robot, el otro iba haciendo los esquemas en Isis y viendo el funcionamiento de este. Para el esquema se utilizo el Arduino Uno puesto que no encontramos la opción de sacar el Mega. El Isis nos proporciono una idea general de como iba a ser el proyecto pero muy virtual y de forma visual.

Para el proyecto se ha utilizado el Arduino mega 2560, principalmente por las salidas PWM de las cuales dispone. El cuadrúpedo esta formado por 9 motores,y esta placa nos los admitía. Ya que con el arduino UNO que habíamos pensado en un principio no tenia tantas salidas PWM para todos los motores.

Una vez teniamos la placa decidimos crear un escudo «shield» para el Mega, para tratar de manipular menos posible la placa de aprendizaje. Intentamos buscar esa Shield por internet pero no dimos con ella, por lo que en Ares nos dispusimos a diseñarla.
Como se ve en la siguiente imagen esta el archivo del diseño en Ares:

Una vez montada la electronica y formado el cuadrupedo nos dispusimos a hacer la parte logica del proyecto, La aplicacion que la controlaria y el codigo para los motores y el ultrasonico.

La tecnología principal de este proyecto es el Bluetooth. Nos decantamos por el bluetooth puesto que necesitábamos algo que no llevase cables y fuese inalámbrico, otro de los factores claves del bluetooth es su simplicidad y la facilidad que Internet ofrece a esta tecnología.

El cuadrúpedo se controla con el móvil mediante un modulo Bluetooth y con un programa creado y diseñado con la aplicación App inventor. El App inventor es una plataforma online para preparar programas, se programa mediante una forma visual y no en código.

Una vez creado el programa App inventor se procederá a su descarga, se nos bajara un archivo .apk  y lo pasaremos al dispositivo Android, únicamente solo con que ejecutemos ese apk se nos instala Nos aparecerá así en nuestro móvil:

La interfaz creada sera tal que asi y se vera de esta forma sencilla:

En el vídeo se observa el programa, y dependiendo los botones que se pulsen el  cuadrúpedo reaccionará de una manera u otra. El programa de Android esta formado por diferentes botones que se explican en el video, excepto dos botones, reset y stop. La primera función es que se quede en el suelo con las piernas abiertas, y stop, es un modo en el que el cuadrúpedo queda apoyado con las cuatro patas pero de forma relajada.

Dispone de un modulo ultrasónico HC-SR04 que permite al cuadrúpedo andar de forma libre, en modo solitario, pero cuando se encuentra con un objeto delante de el, esquivarlo de manera natural para poder seguir andando y moviéndose por el entorno que le rodea.

Según el programa cuando el ultrasónico detecta algún obstáculo a menos de 30cm el cuadrúpedo se dirige hacia atrás.

En el vídeo anterior se observa el programa Android, explicando brevemente lo que ocurre al pulsar los diferentes botones que forman el programa, con su correspondiente reacción del cuadrúpedo.

Como anexo os adjuntamos el programa que hemos utilizado:

#include <Servo.h>
Servo myservoA;  // create servo object to control a servo
Servo myservoB;
Servo myservoC;
Servo myservoD;
Servo myservoE;
Servo myservoF;
Servo myservoG;
Servo myservoH;
Servo myservoQ;
long medir1;
long medir2;
long medir3;
int TrigPin = 12;
int EchoPin = 13;
int A = 90;  //A – Cadera 1
int B = 90;  //B – Cadera 3
int C = 90;  //C – Cadera 5
int D = 90;  //D – Cadera 7
int E = 90;  //E – Pie 2
int F = 90;  //F – Pie 4
int G = 90;  //G – Pie 6
int H = 90;  //H – Pie 8
int Q = 90;
int incomingByte = 0;
#include <SoftwareSerial.h>
SoftwareSerial mySerial(19, 18); // RX, TX
void setup()
{
   // Open serial communications and wait for port to open:
  Serial.begin(9600);
  pinMode(TrigPin,OUTPUT);
  pinMode(EchoPin,INPUT);
  Serial.println(«Hello «);
  Serial.println(«attaching to port_b»);
  myservoA.attach(9);  // attaches the servo on pin 9 to the servo object
  myservoB.attach(8);  // attaches the servo on pin 9 to the servo object
  myservoC.attach(6);  // attaches the servo on pin 9 to the servo object
  myservoD.attach(7);  // attaches the servo on pin 9 to the servo object
  myservoE.attach(2);  // attaches the servo on pin 9 to the servo object
  myservoF.attach(3);  // attaches the servo on pin 9 to the servo object
  myservoG.attach(4);  // attaches the servo on pin 9 to the servo object
  myservoH.attach(5);  // attaches the servo on pin 9 to the servo object
  myservoQ.attach(11);
}
void loop()
{
  long distance;
  distance=medir();
  Serial.print(  medir() );//Serial display distance
  //Serial.print(«cm»);
  Serial.println();
  //delay(1000);
  if (Serial.available() > 0)
  {
    incomingByte = Serial.read();
    Serial.print(«He recibido:»);
    Serial.println(incomingByte,DEC);
  }
 if (incomingByte==0)
  {
    Serial.print(medir());//Serial display distance
    Serial.print(«dm»);
    Serial.println();
  // delay(500);
  }
  if(medir() ==0)
  {
    if (Serial.available() > 0) {
    incomingByte = Serial.read();
    Serial.print(«He recibido:»);
    Serial.println(incomingByte,DEC);
    // delay(500);
    }
  }
if((medir()<80) &( medir()>=30))
{
   cycle_Stop();
   Serial.println();
   cycle_girar();
   Serial.println();
   Serial.print(  medir2);
   Serial.print(«d2mD»);
   Serial.println();
   Serial.print(  medir3);
   Serial.print(«d3mD»);
   Serial.println();
   //delay(1000);
}
   while((medir2>=medir3)&(medir()<80) &( medir()>=30)&(incomingByte==55))
  {
    cycle_Derecha();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print(  medir());//Serial display distance
    Serial.print(«d1mD»);
    Serial.println();
    Serial.print(  medir2);
    Serial.print(«d2mD»);
    Serial.println();
    Serial.print(  medir3);
    Serial.print(«d3mD»);
    Serial.println();
   // delay(2000);
  }
   while((medir2<medir3)&(medir()<80) &( medir()>=30)&(incomingByte==55))
  {
    cycle_Izquierda();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print(  medir());//Serial display distance
    Serial.print(«d1mZ»);
    Serial.println();
    Serial.print(  medir2);
    Serial.print(«d1mZ»);
    Serial.println();
    Serial.print(  medir3);
    Serial.print(«d1mZ»);
    Serial.println();
    //delay(2000);
  }
 if (( medir()<30 )&(incomingByte==55))
  {
    while (( medir()<60 )&(incomingByte==55))
    {
    cycle_Atras();
    if (Serial.available() > 0)
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
    }
    distance=medir();
    Serial.print( medir() );//Serial display distance
    Serial.print(«d0m»);
    Serial.println();
   // delay(1000);
    }
  }
    while((medir() >=80)&(incomingByte==55))
  {
    cycle_Avance();
    distance=medir();
    Serial.print(medir());//Serial display distance
    Serial.print(«d2m»);
    Serial.println();
    //delay(3000);
    if (Serial.available() > 0 )
    {
      incomingByte = Serial.read();
      Serial.print(«He recibido:»);
      Serial.println(incomingByte,DEC);
                       
    }                   
   }
  
   while (incomingByte==50)
   {
     cycle_Avance();
       if (Serial.available() > 0) {
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
       }
     
   }
  
 
     while (incomingByte==53){
      cycle_Stop();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
     
    }
  while (incomingByte==49){
      cycle_Atras();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
     
    }
   
     while (incomingByte==56){
      cycle_Derecha();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
       
    }
   while (incomingByte==52){
      cycle_Izquierda();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
   while (incomingByte==48){
      cycle_Reset();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
     while (incomingByte==54){
      cycle_Avance2();
      if (Serial.available() > 0){
      incomingByte = Serial.read();
       Serial.print(«He recibido:»);
       Serial.println(incomingByte,DEC);
      }
      
    }
}
void   cycle_Avance(){
   for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(200);     // in steps of 10 degree
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(150);
    myservoC.write(90);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                                
    
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(200);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(30);
    myservoB.write(90);
    myservoC.write(150);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Avance»);
  }
void cycle_Stop(){
   myservoE.write( 0);
    myservoH.write(180);
    myservoF.write(0);
    myservoG.write(0);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
    //delay(1000);
    Serial.print(«Stop»);
  }
void cycle_Reset(){
    for(A = 90; A < 150; A += 1)  // goes from 30 degrees to 150 degrees
  {                           // in steps of 10 degree
  
    myservoE.write( 90);
    myservoH.write(90);
    myservoF.write(90);
    myservoG.write(90);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
   
    delay(20);    
                      // waits 15ms for the servo to reach the position
  }
 for(A = 150; A>=91; A-=1)     // goes from 150 degrees to 30 degrees
  {                              
    myservoF.write(90);
    myservoG.write(90);
    myservoE.write(90);
    myservoH.write(90);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
   
    delay(20);   
                      // waits 15ms for the servo to reach the position
  }
}
void   cycle_Atras(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(0);
    myservoH.write( 180);
    myservoF.write(40);
    myservoG.write(40);
    delay(200);     // in steps of 10 degree
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(150);
    myservoC.write(90);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                                
    
    myservoF.write(0);
    myservoG.write(0);
    myservoE.write(40);
    myservoH.write(140);
      delay(200);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(30);
    myservoB.write(90);
    myservoC.write(150);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Atras»);
}
void   cycle_Avance2(){
   for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  { 
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(150);     // in steps of 10 degree
    myservoA.write(60);              // tell servo to go to position in variable ‘A’
    myservoD.write(120);
    myservoB.write(120);
    myservoC.write(60);
    delay(150);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(180);
    myservoA.write(120);              // tell servo to go to position in variable ‘A’
    myservoD.write(60);
    myservoB.write(60);
    myservoC.write(120);   
    delay(180);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«Avance»);
  }
void   cycle_Izquierda(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  {
    myservoE.write(40);
    myservoH.write( 140);
    myservoF.write(0);
    myservoG.write(0);
    delay(180);     // in steps of 10 degree
    myservoA.write(60);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(90);
    delay(180);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {
    myservoF.write(40);
    myservoG.write(40);
    myservoE.write(0);
    myservoH.write(180);
      delay(150);
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(60);
    myservoB.write(90);
    myservoC.write(150);   
    delay(150);             // waits 15ms for the servo to reach the position
  }
    Serial.print(«Izquierda»);
}
void  cycle_Derecha(){
  for(A = 90; A < 150; A += 60)  // goes from 30 degrees to 150 degrees
  {
    myservoE.write(0);
    myservoH.write( 180);
    myservoF.write(40);
    myservoG.write(40);
    delay(200);     // in steps of 10 degree
    myservoA.write(90);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(90);
    myservoC.write(120);
    delay(200);
                 // waits 15ms for the servo to reach the position
  }
  for(A = 150; A>=91; A-=60)     // goes from 150 degrees to 30 degrees
  {                               
    
    myservoF.write(0);
    myservoG.write(0);
    myservoE.write(40);
    myservoH.write(140);
      delay(200);
    myservoA.write(30);              // tell servo to go to position in variable ‘A’
    myservoD.write(90);
    myservoB.write(120);
    myservoC.write(90);   
    delay(200);             // waits 15ms for the servo to reach the position
  }
   Serial.print(«derecha»);
}
long medir(void)
{
  
  long dist,duration;
  digitalWrite(TrigPin,HIGH);//TrigPin prepare high of more than 10us
  delayMicroseconds(11);
  digitalWrite(TrigPin,LOW);
  duration = pulseIn(EchoPin, HIGH);//EchoPin received high start counting until the receiver to the low,return to the count valu
  dist = duration/29/2;//Calculating the distance  cm
                           // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  return dist;
}
void cycle_girar(){
  
  myservoQ.write(0);   //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir2=medir();
  delay(200);        //Retardo entre coordenadas
  myservoQ.write(90);  //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir1=medir();
  delay(200);  //Retardo entre coordenadas
  myservoQ.write(179); //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
  medir3=medir();
  delay(200);        //Retardo entre coordenadas
  myservoQ.write(90);  //Cargamos la funcion con el valor en grados de 0 a 179º
  delay(200);
   Serial.print(«girar»);

 

  }
TWI-TWI, impresora 3D controlada por Android

TWI-TWI, impresora 3D controlada por Android

¿Que es el proyecto TWI – TWI?

De manera sencilla y resumida, la Voladora V2 de Tumaker utiliza una placa llamada Megatronics V3, simplemente es un Arduino Mega 2560 con los pines adaptados para controlar impresoras 3D. Se le ha añadido un modulo Bluetooth a la placa electrónica y se ha creado una aplicación, mediante el programa App Inventor de Google, para controlar la impresora 3D Voladora V2 de Tumaker desde cualquier periférico que utilice el sistema operativo Android.

El objetivo de este proyecto es desarrollar y construir un periférico que controle una impresora 3D, exactamente, la Voladora V2 de Tumaker.

Este proyecto esta formado por tres partes, la comunicación entre el móvil y la impresora 3D Voladora V2 de Tumaker, la aplicación que se crea con App Inventor y el firmaware (el programa que se carga en la placa Megatronics V3) que se llama Marlin.

Comunicación Bluetooth y comunicación Serie
La comunicación  Bluetooth es un protocolo de comunicación inalámbrica de voz y datos.

La comunicación Serie o Serial es un protocolo de comunicación mediante cables de voz y datos que se envía y recibe mediante RX y Tx.

El proyecto TWI – TWI funciona,se envían «comandos» desde el móvil, a la impresora 3D y viceversa. El modulo Bluetooth hace de intermediario entre la impresora 3D y el móvil. El modulo Bluetooth recibe los «comandos» desde el móvil y la impresora 3D. Se utilizan dos tipos de comunicación, la comunicación Serie y la comunicación Bluetooth. La comunicaciòn entre el móvil y el modulo Bluetooth es comunicación Bluetooth, es decir, la información es enviado mediante ondas y la comunicación entre el modulo Bluetooth y la impresora 3D es una comunicación Serie.

Programación

En este proyecto se ha llevado a cabo modificando el Marlin en el sketch de Arduino, el lenguaje en el que se basa Arduino es en C y C++.

Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidisciplinares.

Firmware (Marlin)

Firmware es un programa que es grabado en una memoria, normalmente de lectura/escritura (ROM, EEPROM, flash, etc.), que establece la lógica de más bajo nivel que controla los circuitos electrónicos de un dispositivo de cualquier tipo.
El firmware que utiliza la impresora 3D Voladora V2 de Tumaker es uno llamado Marlin. El mismo firmware sirve para diferentes impresoras 3D, pero se tiene que modificar adaptándolo a la impresora 3D en funciones.

El primer y gran dilema de este proyecto es que se tiene que crear un nuevo puerto serie, muchos os preguntareis porque si puedes utilizar el puerto serie que trae predeterminado la placa. Si se utiliza el mismo puerto serie, la trasmisión de datos se colapsa y ademas no se podrá utilizar la impresora 3D mediante el uso normal, para ello se modifica el firmware «Marlin». La placa electrónica Megatronics V3 de la impresora 3D te da la opción de abrir puertos serie mediante software y hardware.

Los trozos de programa que se modifica en el Marlin.

#include "NewSoftSerial.h"  // Llamada a la libreria NewSoftSerial
#define rxPin 11  //  Declara el pin 11 con el nombre de rxPin
#define txPin 15  //  Declara el pin 15 con el nombre de rxPin
NewSoftSerial miSerial(rxPin, txPin);  //  declara en nombre del puerto serie y define los pines rx y tx

void setup()
{
  miSerial.begin(9600);  // Abre en nuevo puerto serie
  pinMode(3,INPUT);  // declara el pin 3 como entrada
  pinMode(2,OUTPUT);  // declara el pin 2 como salida
  pinMode(rxPin, INPUT); // declara el pin rxPin como entrada
  pinMode(txPin, OUTPUT); // declara el pin txPin como salida

Con el trozo de código de arriba  se consigue abrir el nuevo puerto serie y en este caso el pin 11 es Rx y el pin 15 es Tx. Sin olvidar la velocidad en baudios del nuevo puerto serie, en este caso es de 9600 baudios, es una de las razones por las que puede que al dibujar a mano alzada la impresión se atasque, ya que la impresora 3D y el ordenador se comunican a 115200 baudios. 12 veces mas lento.

void loop()

{
 int estado;  // crear una variable con el nombre estado
 estado=digitalRead(3);  // guardar la lectura del pin 3 en la variable estado
 switch(estado) // mira el valor de la variable estado y ejecutara lo que este dentro del caso 0: caso 1: ...
 {
   case 0: //  ejecutara lo que este dentro siempre que el valor de estado sea 0

   if(buflen < (BUFSIZE-1))


     get_command();
   #ifdef SDSUPPORT
   card.checkautostart(false);
   #endif
   if(buflen)
   {
     #ifdef SDSUPPORT
       if(card.saving)
       {
  if(strstr_P(cmdbuffer[bufindr], PSTR("M29")) == NULL)
  {
    card.write_command(cmdbuffer[bufindr]);
    SERIAL_PROTOCOLLNPGM(MSG_OK);
  }
  else
  {
    card.closefile();
    SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED);
  }
       }
       else
       {
  process_commands();
       }
     #else
       process_commands();
     #endif //SDSUPPORT
     buflen = (buflen-1);
     bufindr = (bufindr + 1)%BUFSIZE;
   }
   //check heater every n milliseconds
   manage_heater();
   manage_inactivity();
   checkHitEndstops();
   lcd_update();
          break;

   case 1:

 if(buflen < (BUFSIZE-1))


  get_command_bluetooth();
   #ifdef SDSUPPORT
   card.checkautostart(false);
   #endif
   if(buflen)
   {
     #ifdef SDSUPPORT
       if(card.saving)
       {
  if(strstr_P(cmdbuffer[bufindr], PSTR("M29")) == NULL)
  {
    card.write_command(cmdbuffer[bufindr]);
    SERIAL_PROTOCOLLNPGM(MSG_OK);
  }
  else
  {
    card.closefile();
    SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED);
  }
       }
       else
       {
  process_commands();
       }
     #else
       process_commands();
     #endif //SDSUPPORT
     buflen = (buflen-1);
     bufindr = (bufindr + 1)%BUFSIZE;
   }
   //check heater every n milliseconds
   manage_heater();
   manage_inactivity();
   checkHitEndstops();
   lcd_update();
          break;
  
  
}

}

void get_command_bluetooth() // es una funcion que se ha creado para interpretar los datos recibidos desde el móvil y ejecutar las acciones
{ 
  while( miSerial.available() > 0  && buflen < BUFSIZE) { // mientras reciba algo superior a 0 por el puerto serie
    serial_char = miSerial.read();

Dentro del Void loop, que es la función principal, se crea este trozo de código para elegir mediante un interruptor la forma de utilizar la impresora 3D Voladora V2 de Tumaker, de manera normal, es decir, controlado por ordenador o controlado por el móvil.

Se ha creado la función void get_command_bluetooth() para interpretar los datos recibidos desde el móvil y ejecutar las acciones.

Se ha creado la función void get_command_bluetooth() para interpretar los datos recibidos desde el móvil y ejecutar las acciones.

App Inventor

App Inventor es un entorno de desarrollo visual de aplicaciones para los teléfonos Android desarrollado por el MIT. Para desarrollar aplicaciones con App Inventor sólo necesitas un navegador web y un teléfono Android.

Al construir las aplicaciones para Android se trabaja con dos herramientas: App Inventor Designer y App Inventor Blocks Editor. En Designer se construye el Interfaz de Usuario, eligiendo y situando los elementos con los que interactuará el usuario. Con el Blocks Editor se define el comportamiento de los componentes de la aplicación.

Esta es la parte visual de la aplicación se ha creado utilizando la herramienta Designer, simplemente son botones, textBox (que es un texto vació para rellenar), texto.

En la imagen de abajo se aprecia el programa entero, mediante el editor de bloques conseguimos asignar acciones a los diferentes objetos de la parte visual.

Todos los bloques tienen una condición, si el modulo bluetooth esta conectado, entonces ejecuta las acciones.

Componentes

-Modulo Bluetooth
-Interruptor
-Voladora V2
-Móvil sistema operativo Android
-Tarjeta SD

Cambios en la impresora 3D Voladora V2 de Tumaker

Se ha modificado la impresora 3D Voladora V2 de Tumaker físicamente para llevar a cavo este proyecto.

Utilizando un pin digital libre de la placa Megatronics V3 se ha colocado un interruptor en forma de pull-up, cuando el interruptor este levantado significa que se controla desde el ordenador y cuando el interruptor este abajo significa que se controla desde el móvil.
Aparte de colocar el interruptor es necesario conectar el modulo Bluetooth e introducir la tarjeta SD con algún G-code cargado en la tarjeta SD.
Esquema de Megatronics V3
En el esquema de arriba se aprecia el conexionado de la placa Megatronics V3, los pines del modulo Bluetooth se conectan Rx al pin 11 y Tx al pin 15 y dos mas que son 5v y 0v.
El interruptor con el sistema pull-up se conecta en el pin 2.

Descargar archivos del proyecto.

Aplicaciones móviles para clase

Aplicaciones móviles para clase

Hace un año tuvimos el cambio de LOGSE a LOE en el ciclo de grado superior de electrónica. En el caso de este ciclo no ha sido un simple ajuste de temarios, los cambios han sido de más calado, pasando de desarrollar circuitos electrónicos a mantenerlos. Como todos los cambios ha habido opiniones para todos los gustos pero en general no acaba de convencer a la mayoría del sistema educativo. El cambio ha supuesto y continúa suponiendo un gran esfuerzo del profesorado para adaptar los temarios, las asignaturas, el material… Todo ello ha coincidido con recortes de sueldos, aumento de ratios, recortes de equipamientos y aumento de matrículas provocados por la crisis. Como a nuestros gobernantes no les ha parecido suficiente, están apunto de cambiar otra vez de sistema educativo para pasar a otro denominado LOMCE, esperemos que por el bien del sistema educativo quede solo en un susto.

Con el cambio a LOE, una de las primeras dudas que tuve en electrónica digital, ahora llamada Equipos Microprogramables (menudo nombrecito), es que ¿Siendo el ciclo mantenimiento, había que seguir dando Karnaugh sin tener que diseñar? La respuesta es si porque está en el DCB, ¿pero con cuanta profundidad? he decido que no mucha. Con 4 entradas y sin profundizar mucho es más que suficiente, no merece la pena dedicar mucho tiempo, porque las posibilidades tecnológicas que hay hoy en día hace que dedicar mucho tiempo a algunas cosas sea perder el tiempo.
Por una parte hay múltiples videos de distintos autores (algunos mejores que otros) donde nos explican las técnicas y como usarlas. Un ejemplo de ello es un video sobre la realización de Mapas de Karnaugh de «profesorparticular09».

Pero además no hace falta dominar la técnica ya que hay software que es capaz de simplificar una tabla de la verdad de múltiples entradas. Sin este software es prácticamente imposible simplificar la tabla a mano cuando tenemos 5, 6, 7… entradas. Para la simplificaciones complejas hasta ahora usaba Multisim 11, aunque es un software simple de usar, supone una larga instalación, muchos Megas de disco duro ocupado, es de pago y le daba un uso muy reducido. Encima para las simulaciones de circuitos digitales usamos Proteus 7 en vez de Multisim 11, por lo que no tiene mucho sentido tener los dos softwares instalados. El problema es que Proteus no trae (o no se la he encontrado) la opción de realizar simplificaciones de tablas de la verdad.
En su lugar acabo de encontrar una solución simple y muy accesible tanto para los alumnos como para mi mismo. En el Play Store de Android hay aplicaciones que realizan esta función. Son muy simples de usar, son gratuitas, realiza simplificaciones de 10 entradas y sin apenas esfuerzo. Aunque hay muchas aplicaciones la que he usado es FLXKarnaugh. Os dejo una imagen para que veáis como queda en una tablet.

Cada vez hay más aplicaciones simples que de una manera sencilla nos ahorra mucho trabajo. Otro tipo de aplicaciones que llevamos usando unos cuantos años, son las aplicaciones para comunicación por bluetooth. La primera que descubrimos fue el «Blue Control«, con este software se obtiene un entorno de botones ideal para poder dirigir un robot o aplicarlo a cualquier proyecto. Aunque está en ingles explicado, es muy sencillo de entender gracias a la ayuda que trae. Su funcionamiento es muy simple al pulsar un botón se envía un carácter por bluetooth, este caracter lo recibe un receptor bluetooth que tenemos conectado a un microcontrolador. Solo nos queda hacer un programa que según el carácter recibido, realice una acción o otra.

Ahora ya no necesitamos tanto el Blue Control ya que hemos ido obteniendo conocimientos y formación en Android. De esta manera los alumnos están pudiendo realizar sus propias aplicaciones con los botones que necesitan y la estructura que quieran. Pero echábamos en falta un Hiperterminal como en Windows pero para el movil, hasta que el año pasado encontramos la aplicación BlueTerm.

Esto va en aumento cada poco tiempo estamos encontrando aplicaciones de móviles que nos ayudan y nos hacen la vida más sencilla. Ya estamos esperando la aplicación que Tknika está desarrollando para hacer el seguimiento de los alumnos en clase. Espero que también desarrollen una aplicación para meter la faltas de asistencia y no tengamos que seguir usando la página web ¿Que aplicaciones habéis encontrado para poder usar en clase?

Sistema de metalización de placas pcb controlado por android

Sistema de metalización de placas pcb controlado por android

Hoy en día, en los procesos industriales, el control de éstos se lleva a cabo mediante órdenes externas, es decir, que el operario puede controlar dicho equipo desde cualquier ubicación sin necesidad de estar enfrente de ésta. Este proceso tiene múltiples ventajas como por ejemplo, el poder visualizarlo en todo momento y actuar si fuese necesario.

En nuestro caso, se trata de realizar un proyecto en el que se controlarán vía bluetooth el funcionamiento de las cubas del metalizado de las placas PCBs, mediante un circuito integrado     (Ilustración-1).
Por otro lado, se visualizará en todo momento la temperatura a la que se encuentran, de manera que se tenga el control sobre las mismas.

 

Ilustración-1

 

Para la creación de este circuito integrado se han utilizado estos materiales:

Componentes                                       Cantidad           Codigo Farnell
Pic 16f886                                                 1                   1579590
Uln 2003                                                   1                    1077215
Leds                                                         7                    1208851
Resistencias                                              7                    9339051
Cristal de 4Mh                                           1                    2057944
Condensador de 22uf                                2                   1216407
Relé de 12v                                              12                   1608330

Dispositivo de bluetooht                            1

Resistencias de calentamiento                 7


ETAPAS DE FABRICACIÓN

.

 *1-Edición del esquema:

            En este apartado, se realizará el esquema (Ilustración-2) equivalente a al circuito integrado que controlará las cubas. Para ello se utilizará un programa llamado ISIS 7 profesional, y posee un gran abanico de posibilidades para la creación de circuitos electrónicos.
Por otro lado, cada componente tiene su huella, de manera que en el caso de que no disponga de ella, habrá que asignarla.
.
Ilustracion-2
 .

 *2-Simulación del circuito:

En este apartado se trata de simular el circuito con el programa ISIS (Ilustración-3). Se utilizaran herramientas como un osciloscopio con el objetivo de captar todas las ondas que ofrezca el circuito

.
Ilustración-3
 .

*3-Prueba del circuito:

La placa board es una placa de conexiones donde se pueden hacer todo tipo de montajes para simular el circuito y así poder comprobar si el funcionamiento de los componentes y del esquema es del todo correcto.

           Para poder llevar a cabo la prueba del circuito (Ilustración-4), se necesitara una placa board con la se podrán montar los componentes y de esto modo, cablearlos.
 .
Ilustración-4

 .

*4-Diseño de la pcb:

El siguiente paso será el de diseñar la PCB (Ilustración-5) de manera que se coloquen las pistas y los componentes en la placa de manera gráfica. Para ello se deberá acudir al programa ISIS y abrir el esquema del circuito que está compuesto por los componentes y sus respectivas huellas. A continuación, se exportaran a otro programa llamado Ares en el cual se diseñara la placa pcb y como ultimo paso, gracias al programa Circuit Cam, se obtendran los archivos necesarios para continuar con la siguiente etapa.

 .
Ilustración-5
 .

*5-Fabricación y montaje:

En este apartado, se utilizara la maquina LPKF. Está constituida por una fresadora capaz de hacer pistas y agujeros utilizando distintas herramientas a su disposición, y un aspirador propio para las virutas que se generan.

Una vez concluida la etapa de fabricación de la placa PCB. Y se tenga la placa lista, se procederá al montaje y comprobación de las pistas.
  .

 *7-Maquina de 3 dismensiones:

Gracias a esta maquina, se pueden realizar objetos en 3 dimensiones. Estas maquetas se hacen con un material de plastico y se llevan a cabo mediante un programa llamado autocad. En nuestro caso se hará una caja con una tapa y unos orificios donde iran colocados los sensores lm35 (Ilustración-6).

    .
Ilustración-6

.    

*6-Sistema de comunicación vía bluetooth:

Es imprescindible que el manejo del proyecto sea  mediante un sistema que permita su control total desde un teléfono móvil (Ilustración-7).

           La comunicación bluetooth será el sistema elegido.Este sistema esta formado por dos partes:

                                    -La parte grafica, en donde el usuario puede interactuar con ella.
                                    -La parte de comandos, donde se programa.
  Ilustración-7


Vídeo de demostración:

 
A continuación os dejamos un vídeo de demostración del prototipo que hemos realizado y los archivos de todo el proyecto.
.