main.cpp

00001 #include "mbed.h"
00002 #include "datos.h"
00003  
00004 Serial pc(SERIAL_TX, SERIAL_RX);
00005 SPI deviceM(PA_7,PA_6, PA_5);
00006 DigitalOut ssel (PA_4);
00007 //InterruptIn girop(PF_1);
00008 //InterruptIn posicionmas(PF_0);
00009 //InterruptIn posicionmenos(PA_8);
00010  void Rx_interrupt();
00011  
00012 #define  uint8_t unsigned char
00013 uint8_t screen[8]={0,0,0,0,0,0,0,0};
00014 uint8_t screen2[8]={0,0,0,0,0,0,0,0};
00015 uint8_t verifica;
00016 uint8_t mascara,mascarax;
00017 int velocidad, pieza,giro;
00018 uint8_t cambio;
00019 
00020 ///////////////////////////////////////////////////////////////////////////////
00021 void sendSPI(uint8_t d1, uint8_t d2)// envio de datos al max
00022 {
00023     deviceM.unlock();
00024     ssel=0;
00025     deviceM.write(d1); 
00026     deviceM.write(d2);  
00027     ssel=1;
00028     deviceM.lock();
00029 };
00030 
00031 ///////////////////////////////////////////////////////////////////////////////
00032 void borrar()    // Borrar todos los datos de la matriz
00033 {
00034    int j;
00035      for(j=1;j<9;j++)
00036      {
00037       sendSPI(j,0);
00038       wait_ms(1);
00039      }
00040 }
00041 ///////////////////////////////////////////////////////////////////////////////
00042 void escribir()   // Guarda y compara los datos entrantes a la matriz y los que ya estaban
00043 {
00044 int i,j;
00045  
00046      for(i=0;i<tamano;i++)
00047      {
00048          screen2[posicion-i]=(start[posicion-i] & 128);
00049          start[posicion-i]=start[posicion-i] << 1;
00050      }   
00051      
00052      for(i=0;i<tamano;i++)
00053      {
00054          screen[posicion-i]=((((screen[posicion-i]>>1) & ~(mascara-1)) | (screen[posicion-i] & (mascara-1))) | screen2[posicion-i] ) | (screen[posicion-i] & (mascara));
00055      }    
00056      //enviar
00057      for(j=0;j<8;j++)
00058       {         
00059        sendSPI(j+1,screen[j]); 
00060        //pc.printf(" posicion %d",j);
00061        //pc.printf("--> %d \n",screen[j]);
00062       }
00063       //pc.printf("----------\n");
00064 }    
00065 ///////////////////////////////////////////////////////////////////////////////
00066 int ubicacion()            //Limita el ingreso de posicion no mayor a 7
00067 {
00068     int a;
00069     if((posicion_original+tamano) <= 8 && (posicion_original+tamano) >= 0  )
00070     {
00071       a=1;
00072     }
00073     else
00074     {
00075       a=0;
00076     }    
00077     return a;
00078 }
00079 ///////////////////////////////////////////////////////////////////////////////
00080 void analisis()  // Verifica la siguiente fila para saber si se puede desplazar 
00081 {
00082 int i;
00083 uint8_t a;
00084        
00085        for(i=0;i<tamano;i++)
00086        {
00087             a=screen[posicion-i] & mascara;
00088             a= a & ((screen[posicion-i]>>1) & ~(mascara-1));
00089            
00090             if(mascara==a)
00091             {
00092              i=tamano;
00093              verifica=1;
00094             }  
00095             else
00096             {
00097             verifica=0;       
00098             }
00099        }  
00100 } 
00101 //////////////////////////////////////////////////////////////////////////////
00102 void nuevo () //pide nuevamente los datos de la pieza con los cambios de giro o posicion
00103 {
00104    int k;
00105   
00106     for(k=0;k<tamano;k++)//borra la pieza que habia 
00107     {   
00108       screen[posicion-k]=screen[posicion-k]&(mascara-1);
00109     }
00110     mascara=128;//se coloca 128 para que baje completa la pieza
00111     tamano=0;
00112     posicion=posicion_original;
00113         
00114         switch(pieza)//vuelve a colocar los datos de la pieza con los cambios
00115              {                          
00116                    case 0: a(giro);   break;                       
00117                    case 1: b(giro);   break;  
00118                    case 2: c(giro);   break; 
00119                    case 3: d(giro);   break;  
00120                    case 4: e(giro);   break;  
00121                    case 5: f(giro);   break; 
00122                    case 6: g(giro);   break;  
00123                    default: pc.printf("Error en figura \n");
00124              } 
00125 
00126 }         
00127 //////////////////////////////////////////////////////////////////////////////
00128 int analisis2()//INTENTO DE RESTRINGIR EL GIRO
00129 {   
00130    int b;
00131    
00132    if(mascara<=((screen[posicion-1])+1) || mascara<=((screen[posicion+tamano])+1))  
00133    {
00134       b=0;
00135    } 
00136    else 
00137    {
00138       b=1;
00139    }
00140    
00141    return b;
00142 }    
00143 //////////////////////////////////////////////////////////////////////////////
00144 void giros() //interrupcion cuando se oprime el boton de giro 
00145 {
00146  int girox,posicionx;
00147  int a=1;
00148  int b=1;
00149  
00150  cambio=1;//entra al cambio de velocidad para la visualizacion dinamica
00151  mascarax=mascara;   //guarda la posicion de donde estaba la pieza que es hasta donde se debe hacer la visualizacion 
00152  girox=giro;
00153  posicionx=posicion_original;
00154                 
00155    giro=giro+1;
00156    if(giro>=4) giro=00;//limita el giro 
00157    b=analisis2();//LA IDEA ES QUE AQUI ANALICE SI PUEDE GIRARSE
00158    nuevo();//se  pide esta funcion para que antes de hacer el analisis de ubicacion coloque los datos nuevos teniendo en cuenta que si sa cambia el giro cambia el tamano
00159    a=ubicacion();
00160    if (a==0 | b==0)///cuando esta fuera de los limites vuelve a mandar los mismos datos de la pieza que estaba
00161    {
00162      giro=girox;
00163      posicion_original=posicionx;
00164   }
00165   nuevo();   //se pide esta funcion nuevamente porque en dado caso de que no este en lo limites se vuelvan a enviar los mismos datos
00166   
00167   wait_ms(700);
00168 }
00169 //////////////////////////////////////////////////////////////////////////////
00170 void pmenos()    //interrupcion de poscion menos
00171 {
00172   int girox,posicionx;
00173   int a=1;
00174   int b=1;
00175 
00176   cambio=1;//entra al cambio de velocidad para la visualizacion dinamica
00177   mascarax=mascara;   //guarda la posicion de donde estaba la pieza que es hasta donde se debe hacer la visualizacion 
00178   girox=giro;
00179   posicionx=posicion_original;
00180 
00181   posicion_original=posicion_original-1;
00182   b=analisis2();//LA IDEA ES QUE AQUI ANALICE SI PUEDE CORRERSE 
00183   a=ubicacion();
00184   if (a==0 | b==0)//cuando esta fuera de los limites vuelve a mandar los mismos datos de la pieza que estaba
00185   {
00186      giro=girox;
00187      posicion_original=posicionx;
00188   }
00189   nuevo();// solo se solicita una vez esta funcion ya que lo unico que varia es la posicion 
00190   wait_ms(500);
00191 }    
00192 //////////////////////////////////////////////////////////////////////////////
00193 void pmas() //interrupcion posicion mas
00194 {
00195   int girox,posicionx;
00196   int a=1;
00197   int b=1;
00198   
00199   cambio=1;//entra al cambio de velocidad para la visualizacion dinamica
00200   mascarax=mascara; //guarda la posicion de donde estaba la pieza que es hasta donde se debe hacer la visualizacion  
00201   girox=giro;
00202   posicionx=posicion_original;
00203   
00204   posicion_original=posicion_original+1;  
00205   b=analisis2();//LA IDEA ES QUE AQUI ANALICE SI PUEDE CORRERSE
00206   a=ubicacion();
00207   
00208   if (a==0 | b==0)//cuando esta fuera de los limites vuelve a mandar los mismos datos de la pieza que estaba
00209   {
00210       giro=girox;
00211       posicion_original=posicionx;
00212   }
00213   nuevo();
00214   wait_ms(500);
00215 }
00216 //////////////////////////////////////////////////////////////////////////////
00217 void play ()  // Funcion encargada de determinar el estado de la mascara
00218 {
00219 cambio=0;
00220 int a=1;
00221 mascara=128;
00222 velocidad=1;
00223 a=ubicacion();
00224 
00225     while(a==1)
00226     {   
00227         analisis();
00228           
00229         if (verifica==1)a=0;
00230         else 
00231         {   
00232                              
00233            if(cambio==1)//cambio de velocidad para poder hacer visualizacion dinamica cada vez que se presiona un pulsador
00234             {
00235                 if(mascarax!=mascara)velocidad=0;//mientras cae a la posicion que estaba va a tener esta velocidad
00236                 else 
00237                 {
00238                     velocidad=1;  
00239                     cambio=0;
00240                  }   
00241             } 
00242             else velocidad=1;
00243             
00244            // girop.rise(&giros);//interrupcion giro
00245             //posicionmenos.rise(&pmenos);//interrupcion posicion menos
00246             //posicionmas.rise(&pmas);//interrupcion posicion mas
00247             
00248             escribir();  
00249             mascara=mascara/2; 
00250             wait(velocidad);
00251             }
00252     }     
00253 }
00254 ///////////////////////////////////////////////////////////////////////////////         
00255 int main() { // fucnion principal 
00256  
00257         pc.baud(9600);
00258         pc.attach(&Rx_interrupt, Serial::RxIrq);
00259  
00260         sendSPI(0x0c,1);
00261         sendSPI(0x0F,1);
00262         wait (1);
00263                     
00264         sendSPI(0x0F,0);
00265         wait (1);
00266         sendSPI(0xB,0x7);
00267         borrar();
00268         int inicio,fin; 
00269         
00270           while(1){
00271            //pide los datos por el serial
00272            inicio=60;                  
00273            pieza=10;
00274 
00275   
00276            while( pieza>6)
00277            {
00278              pieza=rand ()% 16;
00279              pc.printf("%d ",pieza);
00280             }
00281            posicion=3;
00282            giro = 0;
00283              
00284            fin=62;          
00285                        
00286                        if((inicio==60) && (fin==62))
00287                        {
00288                                switch(pieza)
00289                                {                          
00290                                       case 0: a(giro); play();  break;                       
00291                                       case 1: b(giro); play();  break;  
00292                                       case 2: c(giro); play();  break; 
00293                                       case 3: d(giro); play();  break;  
00294                                       case 4: e(giro); play();  break;  
00295                                       case 5: f(giro); play();  break; 
00296                                       case 6: g(giro); play();  break;  
00297                                       default: pc.printf("Error en figura \n");
00298                                }     
00299                         }                       
00300          } 
00301 } 
00302 
00303 
00304 void Rx_interrupt() {
00305  
00306     char d = pc.getc();
00307     pc.printf("numero %d\n",d);
00308     
00309     
00310     switch(d)
00311     {
00312       case 97:  pmenos(); break;
00313       case 100: pmas(); break;
00314       case 119: giros(); break;
00315        default: pc.printf("Error  \n");
00316         
00317      }   
00318 
00319     return; 
00320 }