main.cpp

00001 #include "mbed.h"
00002 #include "datos.h"
00003 
00004 
00005 Serial pc(SERIAL_TX, SERIAL_RX);
00006 SPI deviceM(PB_15, PB_14, PB_13);
00007 DigitalOut ssel (PB_12);
00008 void Rx_interrupt();
00009 
00010 #define  uint8_t unsigned char
00011 uint8_t screen[8]={0,0,0,0,0,0,0,0};
00012 uint8_t screen2[8]={0,0,0,0,0,0,0,0};
00013 uint8_t verifica;
00014 uint8_t mascara;
00015 int velocidad=1000;
00016 int segundo=1;
00017 int verificacion=0;
00018 int rapido =1000;
00019 int vericolor=0;
00020 
00021 
00022 // variables y definiciones color
00023 DigitalOut s0(D3); 
00024 DigitalOut s1(D4);
00025 DigitalOut s2(D5); 
00026 DigitalOut s3(D6);
00027 
00028 DigitalOut led_col(D7); 
00029 DigitalOut led1(LED1);
00030 DigitalIn out(D2);  
00031 
00032 Timer tiempo;
00033 
00034 int valor,verificacion_color ;
00035 int val_color;
00036 int val_r,val_g,val_b;
00037 int ch_color;
00038 void analisis (void);
00039 
00040 #include "Movimiento.h"
00041 //////////////////////////////////////////////////////////////////////////////
00042 
00043 void analisis_color(void)
00044 {
00045    while(verificacion_color==0)
00046    {
00047         valor=out.read();
00048        // pc.printf("valor 1=   %d \n",valor);
00049         if (valor==1)
00050         {
00051          while(verificacion_color==0)
00052          {
00053             valor=out.read();            
00054          //   pc.printf("valor 2=   %d \n",valor);
00055             
00056             if(valor==0)
00057             {
00058              tiempo.start();
00059             }   
00060             while(valor==0)
00061             {
00062              valor=out.read();
00063            //  pc.printf("valor 3=   %d \n",valor);
00064              verificacion_color=1;
00065             }   
00066           } 
00067         }   
00068      }
00069   val_color=tiempo.read_us();
00070   tiempo.reset();
00071   verificacion_color=0;
00072 }
00073 
00074 
00075 ///////////////////////////////////////////////////////////////////////////////
00076 void datos_color(void)
00077 { 
00078         s2=0;
00079        s3=0;
00080        analisis();
00081      //pc.printf("Rojox=    %d \n",val_color);
00082        val_r=val_color;
00083        wait_ms(100);
00084        
00085      
00086        s2=0;
00087        s3=1;
00088        analisis();
00089        //pc.printf(" Azul=    %d \n ",val_color);
00090        val_b=val_color;
00091        wait_ms(100);
00092        
00093        
00094        s2=1;
00095        s3=1;
00096        analisis();
00097        //pc.printf(" Verde=    %d \n",val_color);
00098        val_g=val_color;
00099        wait_ms(100);   
00100        
00101        
00102        //Blanco
00103        if((val_r>=600047 && val_r<=600115) &&(val_g>=100051 && val_g<=100108) && (val_b>=100044 && val_b<=100086))
00104        {
00105              pc.printf(" Blanco \n");
00106         }   
00107       //rojo
00108          if((val_r>=600116 && val_r<=600282) &&(val_g>=100305 && val_g<=100853) && (val_b>=100191 && val_b<=100550))
00109        {
00110              pc.printf(" Rojo \n");
00111         }
00112         //verde
00113               
00114      if((val_r>=600283 && val_r<=600669) &&(val_g>=100143 && val_g<=100395) && (val_b>=100147 && val_b<=100409))
00115        {
00116              pc.printf(" Verde \n");
00117         }
00118                        
00119        //Azul
00120               
00121         if((val_r>=600570 && val_r<=601153) &&(val_g>=100199 && val_g<=100553) && (val_b>=100103 && val_b<=100122))
00122        {
00123              pc.printf(" Azul \n");
00124         }
00125     
00126 }
00127 
00128 //////////////////////////////////////////////////////////////////////////////
00129 void color_interrupcion (void)
00130 {
00131     
00132     switch(ch_color)
00133     {
00134       case 1:  pmenos(); break;
00135       case 2: pmas(); break;
00136       case 3: giros(); break;
00137       default: pc.printf("Error  \n");
00138         
00139      }
00140 }
00141 
00142 ///////////////////////////////////////////////////////////////////////////////
00143 void sendSPI(uint8_t d1, uint8_t d2)// envio de datos al max
00144 {
00145     deviceM.unlock();
00146     ssel=0;
00147     deviceM.write(d1); 
00148     deviceM.write(d2);  
00149     ssel=1;    deviceM.lock();
00150 };
00151 ///////////////////////////////////////////////////////////////////////////////
00152 void borrar()    // Borrar todos los datos de la matriz
00153 {
00154    int j;
00155      for(j=1;j<9;j++)
00156      {
00157       sendSPI(j,0);
00158       wait_ms(1);
00159      }
00160 }
00161 ///////////////////////////////////////////////////////////////////////////////
00162 void enviar()   // Encargado de enviar la matriz completa
00163 {
00164    int i;
00165  
00166       for(i=0;i<8;i++)
00167       {
00168        sendSPI(i+1,screen[i]);      
00169       }    
00170 }   
00171 ///////////////////////////////////////////////////////////////////////////////
00172 void ver()      //  Informe de datos "no se usa "
00173 {
00174  int i;
00175        for(i=0;i<8;i++)
00176        {
00177          pc.printf("posicion %d ",i);
00178          pc.printf("=  %d \n",screen[i]);     
00179        }      
00180 }  
00181 ///////////////////////////////////////////////////////////////////////////////
00182 void escribir()   // Guarda y compara los datos entrantes a la matriz y los que ya estaban
00183 {
00184 int i;
00185  
00186      for(i=0;i<tamano;i++)
00187      {
00188          screen2[posicion-i]=(start[posicion-i] & 128);
00189          start[posicion-i]=start[posicion-i] << 1;
00190      }   
00191      
00192      //pc.printf("1 \n");
00193      //ver();
00194      
00195      
00196      for(i=0;i<tamano;i++)
00197      {
00198          screen[posicion-i]=((((screen[posicion-i]>>1) & ~(mascara-1)) | (screen[posicion-i] & (mascara-1))) | screen2[posicion-i] ) | (screen[posicion-i] & mascara) | (screen[posicion-i] & mascara*segundo);
00199      }    
00200      
00201      //pc.printf("2 \n");
00202      //ver();
00203      enviar();
00204 }    
00205 ///////////////////////////////////////////////////////////////////////////////
00206 int ubicacion()            //Limita el ingreso de posicion no mayor a 7
00207 {
00208     int a;
00209     if((posicion_original+tamano) <= 8 && (posicion_original+tamano) >= 0  )
00210     {
00211       a=1;
00212     }
00213     else
00214     {
00215       //pc.printf("Error de posicion \n");
00216       //pc.printf("Posicion original %d \n",posicion_original);
00217       //pc.printf("tamano  %d \n",tamano);
00218       a=0;
00219     }    
00220     return a;
00221 }
00222 ///////////////////////////////////////////////////////////////////////////////
00223 void analisis()  // Verifica la siguiente fila para saber si se puede desplazar 
00224 {
00225 int i;
00226 uint8_t a;
00227        
00228        for(i=0;i<tamano;i++)
00229        {
00230             a=screen[posicion-i] & mascara;
00231          // pc.printf("verificacion siguiente fila = %d \n ",a);
00232             if(mascara==a)
00233             {
00234              i=tamano;
00235              verifica=1;
00236             }  
00237             else
00238             {
00239              verifica=0;     
00240             }
00241        }    
00242 }     
00243 ////////////////////////////////////////////////////////////////////////////////
00244 void analisis2()   // Prueba 
00245 {
00246     int i;
00247     uint8_t a;
00248        
00249        for(i=0;i<tamano;i++)
00250        {
00251             a=screen[posicion-i] & mascara;
00252             a= a & ((screen[posicion-i]>>1) & ~(mascara - 1));  
00253             //pc.printf("verificacion siguiente fila = %d \n ",a);
00254             if(a!=0)
00255             {
00256              i=tamano;
00257              verifica=1;
00258              segundo=1;
00259              if(verificar2==1)
00260              {
00261                  verificar2=0;
00262                  verifica=0;
00263                  segundo=2;
00264              }   
00265             }  
00266             else
00267             {
00268              segundo=1;
00269              verifica=0;     
00270             }
00271        }    
00272     
00273 }
00274 ///////////////////////////////////////////////////////////////////////////////
00275 void play ()  // Funcion encargada de determianr el estado de la mascara
00276 {
00277  
00278  pc.attach(&Rx_interrupt, Serial::RxIrq);
00279  int a=1;
00280   mascara=128;
00281   //pc.printf("Posicion original 1 %d \n",posicion_original);
00282   a=ubicacion();
00283     while(a==1)
00284     {
00285      analisis2();
00286           
00287           if(verificacion==1)
00288           {
00289               return;
00290           }
00291           
00292           
00293         if (verifica==1 || mascara==0)
00294         {
00295          a=0;
00296 
00297         }
00298         else 
00299         {
00300 
00301          escribir();  
00302               
00303                if(verificacion==1)
00304                {
00305                 return;
00306                 }
00307              
00308          
00309          if(mascara==mascarax)
00310          {
00311           velocidad=rapido;
00312 
00313           }
00314           
00315                      wait_ms(velocidad);
00316           /*   
00317           for(int ch=0;ch<=1;ch++)
00318           { 
00319              datos_color();
00320              wait_ms(1);
00321              if(vericolor==1)
00322              {
00323               color_interrupcion();
00324              }   
00325           }
00326           */
00327          
00328          mascara=mascara/2; 
00329          
00330          
00331         
00332         }
00333     }            
00334 }
00335 
00336 ///////////////////////////////////////////////////////////////////////////////
00337           
00338 int main() { // fucnion principal 
00339     pc.baud(9600);
00340     
00341         sendSPI(0x0c,1);
00342         sendSPI(0x0F,1);
00343         wait (1);
00344                     
00345         sendSPI(0x0F,0);
00346         wait (1);
00347         sendSPI(0xB,0x7);
00348         borrar();
00349 
00350           led_col=1;
00351           //escala de frecuencia a 20%
00352           s0=1;
00353           s1=0;
00354                     
00355         int n;
00356       
00357         int inicio , fin;
00358           
00359        
00360           while(1){
00361            
00362            
00363             if(verificacion==0)
00364             {
00365              /*
00366                n=10; 
00367               while( n>6)
00368               {
00369                 n=rand ()% 16;
00370                // pc.printf("%d ",n);
00371               }
00372                 posicion=3;
00373                 giro = 0;
00374                 wait(0.2);
00375                 mascarax=128;
00376             */
00377               pc.attach(0, Serial::RxIrq);
00378              inicio=pc.getc();
00379            
00380             if(inicio==60)
00381             {
00382             
00383             
00384            
00385              mascarax=128;
00386              //pc.printf("Ingrese el numero de la figura \n");
00387              inicio=60;
00388               
00389              n = pc.getc();  
00390              //pc.printf("figura  %d \n ",n);
00391                                       
00392              //pc.printf("Ingrese el numero de angulo de giro \n");
00393              giro = pc.getc();
00394              //pc.printf("giro %d \n ",giro);
00395                        
00396              //pc.printf("Ingrese la posicion  \n");
00397               posicion = pc.getc();
00398               //pc.printf("posicion %d \n ",posicion);  
00399             
00400               fin=pc.getc();           
00401               wait(0.2);
00402              }
00403             }
00404              else
00405              {
00406              verificacion=0;
00407              posicion=posicion_original;            
00408              }
00409                        
00410            if((inicio==60) && (fin==62))
00411            {
00412                        switch(n)
00413                        {
00414                          case 0: a(giro); play(); break;  
00415                                                   
00416                          case 1: b(giro); play(); break;  
00417                          
00418                          case 2: c(giro); play(); break;  
00419                          
00420                          case 3: d(giro); play(); break;  
00421                          
00422                          case 4: e(giro); play(); break;  
00423                          
00424                          case 5: f(giro); play(); break;  
00425                          
00426                          case 6: g(giro); play(); break;  
00427                           
00428                         default: pc.printf("Error en figura \n");                           
00429                       }
00430             }             
00431          }                
00432 }
00433 ////////////////////////////////////////////////////////////////////////////////////////////////
00434 void Rx_interrupt() {
00435  
00436     char d = pc.getc();
00437     pc.printf("numero %d\n",d);
00438     
00439     
00440     switch(d)
00441     {
00442       case 97:  pmenos(); break;
00443       case 100: pmas(); break;
00444       case 119: giros(); break;
00445       default: pc.printf("Error  \n");
00446         
00447      }   
00448 
00449     return; 
00450 }
00451 
00452