Revision 1:899567984090, committed 2018-10-16

Comitter:

NataliaGaravito

Date:

Tue Oct 16 23:31:40 2018 +0000

Parent:

0:830a26e0a86c

Commit message:

matriz;

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datos.h	Tue Oct 16 23:31:40 2018 +0000
@@ -0,0 +1,273 @@
+#include "mbed.h"
+ 
+uint8_t start[8]={0,0,0,0,0,0,0,0};
+int tamano;
+uint8_t posicion;
+uint8_t posicion_original;
+void start0()
+{
+  int i;
+  for (i=0;i<7;i++)
+  {
+      start[i]=0;
+  }
+}
+
+void a(uint8_t giro)
+{
+      start0();
+      posicion_original=posicion;
+      posicion=7-posicion;
+      switch(giro)
+      { 
+        case 0:
+         start[posicion-2]=0b10000000;
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b10000000;
+         tamano=3;
+        break;
+        
+        case 1:
+         start[posicion-1]=0b01000000;
+         start[posicion-0]=0b11100000;
+         tamano=2;
+        break;
+        
+        case 2:
+         start[posicion-2]=0b01000000;
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b01000000;
+         tamano=3;
+        break;
+        
+        case 3:
+         start[posicion-1]=0b11100000;
+         start[posicion-0]=0b01000000;
+         tamano=2;
+        break;
+        
+        default: posicion_original=20;
+      } 
+}
+void b(uint8_t giro)
+{
+      start0();
+      posicion_original=posicion;
+      posicion=7-posicion;
+      
+      switch(giro)
+      { 
+        case 0:
+         start[posicion-0]=0b11100000;
+         tamano=1;
+        break;
+        
+        case 1:
+         start[posicion-2]=0b10000000;
+         start[posicion-1]=0b10000000;
+         start[posicion-0]=0b10000000;
+         tamano=3;
+        break;
+        
+        case 2:
+         start[posicion-0]=0b11100000;
+         tamano=3;
+        break;
+        
+        case 3:
+         start[posicion-2]=0b10000000;
+         start[posicion-1]=0b10000000;
+         start[posicion-0]=0b10000000;
+         tamano=3;
+        break;
+ 
+        default: posicion_original=20;
+      }  
+}
+ 
+void c(uint8_t giro)
+{
+      start0();
+      posicion_original=posicion;
+      posicion=7-posicion;
+      switch(giro)
+      { 
+        case 0:
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b11000000;
+         tamano=2;
+        break;
+        
+        case 1:
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b11000000;
+         tamano=2;
+        break;
+        
+        case 2:
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b11000000;
+         tamano=2;
+        break;
+        
+        case 3:
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b11000000;
+         tamano=2;
+        break;
+        
+        default: posicion_original=20;
+      } 
+}
+ 
+void d(uint8_t giro)
+{
+      start0();
+      posicion_original=posicion;
+      posicion=7-posicion;
+      switch(giro)
+      { 
+        case 0:
+         start[posicion-1]=0b11100000;
+         start[posicion-0]=0b10000000;
+         tamano=2;
+        break;
+        
+        case 1:
+         start[posicion-2]=0b10000000;
+         start[posicion-1]=0b10000000;
+         start[posicion-0]=0b11000000;
+         tamano=3;
+        break;
+        
+        case 2:
+         start[posicion-1]=0b00100000;
+         start[posicion-0]=0b11100000;
+         tamano=2;
+        break;
+        
+        case 3:
+         start[posicion-2]=0b11000000;
+         start[posicion-1]=0b01000000;
+         start[posicion-0]=0b01000000;
+         tamano=3;
+        break;
+        default: posicion_original=20;
+      }      
+}
+ 
+void e(uint8_t giro)
+{
+      start0();
+      posicion_original=posicion;
+      posicion=7-posicion;
+      switch(giro)
+      { 
+        case 0:
+         start[posicion-1]=0b10000000;
+         start[posicion-0]=0b11100000;
+         tamano=2;
+        break;
+        
+        case 1:
+         start[posicion-2]=0b01000000;
+         start[posicion-1]=0b01000000;
+         start[posicion-0]=0b11000000;
+         tamano=3;
+        break;        
+        
+        case 2:
+         start[posicion-1]=0b11100000;
+         start[posicion-0]=0b00100000;
+         tamano=2;
+        break;        
+        
+        case 3:
+         start[posicion-2]=0b11000000;
+         start[posicion-1]=0b10000000;
+         start[posicion-0]=0b10000000;
+         tamano=3;
+        break;
+        
+        default: posicion_original=20;
+      
+      }
+}
+ 
+void f (uint8_t giro)
+{
+      start0();
+      posicion_original=posicion;
+      posicion=7-posicion;
+      switch(giro)
+      { 
+        case 0:
+         start[posicion-2]=0b10000000;
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b01000000;
+         tamano=3;
+        break;
+        
+        case 1:
+         start[posicion-1]=0b01100000;
+         start[posicion-0]=0b11000000;
+         tamano=2;
+        break;
+        
+        case 2:
+         start[posicion-2]=0b10000000;
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b01000000;
+         tamano=3;
+        break;
+        
+        case 3:
+         start[posicion-1]=0b01100000;
+         start[posicion-0]=0b11000000;
+         tamano=2;
+        break;
+        
+        default: posicion_original=20;
+      
+      }
+      
+}
+
+void g (uint8_t giro)
+{
+      start0();
+      posicion_original=posicion;
+      posicion=7-posicion;
+      switch(giro)
+      { 
+        case 0:
+         start[posicion-2]=0b01000000;
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b10000000;
+         tamano=3;
+        break;
+        
+        case 1:
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b01100000;
+         tamano=2;
+        break;
+           
+        case 2:
+         start[posicion-2]=0b01000000;
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b10000000;
+         tamano=3;
+        break;
+        
+        case 3:
+         start[posicion-1]=0b11000000;
+         start[posicion-0]=0b01100000;
+         tamano=2;
+        break;
+        
+        default: posicion_original=20;
+      
+      }
+      
+}
\ No newline at end of file

--- a/main.cpp	Thu Aug 30 12:51:47 2018 +0000
+++ b/main.cpp	Tue Oct 16 23:31:40 2018 +0000
@@ -1,17 +1,23 @@
 #include "mbed.h"
-//#include "max7219.h"
+#include "datos.h"
+ 
+Serial pc(SERIAL_TX, SERIAL_RX);
+SPI deviceM(PA_7,PA_6, PA_5);
+DigitalOut ssel (PA_4);
+InterruptIn girop(PF_1);
+InterruptIn posicionmas(PF_0);
+InterruptIn posicionmenos(PA_8);
+ 
+#define  uint8_t unsigned char
+uint8_t screen[8]={0,0,0,0,0,0,0,0};
+uint8_t screen2[8]={0,0,0,0,0,0,0,0};
+uint8_t verifica;
+uint8_t mascara,mascarax;
+int velocidad, pieza,giro;
+uint8_t cambio;
 
-// ***************************************************************************
-// option 1 : use  SPI
-// ***************************************************************************
-SPI deviceM(PB_15, PB_14, PB_13);
-DigitalOut ssel (PB_12);
-
-#define  uint8_t unsigned char
-uint8_t vcol2[8]={0,0,0,0,0,0,0,0};
-
- 
-void sendSPI(uint8_t d1, uint8_t d2)
+///////////////////////////////////////////////////////////////////////////////
+void sendSPI(uint8_t d1, uint8_t d2)// envio de datos al max
 {
     deviceM.unlock();
     ssel=0;
@@ -21,130 +27,263 @@
     deviceM.lock();
 };
 
-
-void printMatrix(uint8_t*  vC)
-
+///////////////////////////////////////////////////////////////////////////////
+void borrar()    // Borrar todos los datos de la matriz
 {
-    uint8_t i =0;
-    for (i=0;i<8;i++){
-        sendSPI(i,*(vC+i));
-    }
-        
-    };
-
-void clr_vcol()
-    {
-    for (int i=0; i<8;i++){
-            vcol2[i]=0;
-    }
-    
-}   
+   int j;
+     for(j=1;j<9;j++)
+     {
+      sendSPI(j,0);
+      wait_ms(1);
+     }
+}
+///////////////////////////////////////////////////////////////////////////////
+void escribir()   // Guarda y compara los datos entrantes a la matriz y los que ya estaban
+{
+int i,j;
  
-void print_Snake2()
-{   
-    int j, i;
-      //reset
-    
-    for (j=0; j<8;j++){
-        clr_vcol();
-        if(j % 2 == 0)
-            vcol2[j]=1;
-        else
-            vcol2[j]=0b10000000;
-    
-        for (i=0; i<8;i++){
-            if(j % 2 == 0){
-                 vcol2[j]=3<<i;
-                }
-            else{
-                 vcol2[j]=0b111100111111>>i;
-                }
-            printMatrix(vcol2);
-            wait_ms(5);
-            }
-        }
+     for(i=0;i<tamano;i++)
+     {
+         screen2[posicion-i]=(start[posicion-i] & 128);
+         start[posicion-i]=start[posicion-i] << 1;
+     }   
+     
+     for(i=0;i<tamano;i++)
+     {
+         screen[posicion-i]=((((screen[posicion-i]>>1) & ~(mascara-1)) | (screen[posicion-i] & (mascara-1))) | screen2[posicion-i] ) | (screen[posicion-i] & (mascara));
+     }    
+     //enviar
+     for(j=0;j<8;j++)
+      {         
+       sendSPI(j+1,screen[j]); 
+       //pc.printf(" posicion %d",j);
+       //pc.printf("--> %d \n",screen[j]);
+      }
+      //pc.printf("----------\n");
+}    
+///////////////////////////////////////////////////////////////////////////////
+int ubicacion()            //Limita el ingreso de posicion no mayor a 7
+{
+    int a;
+    if((posicion_original+tamano) <= 8 && (posicion_original+tamano) >= 0  )
+    {
+      a=1;
+    }
+    else
+    {
+      a=0;
+    }    
+    return a;
 }
-
-void print_Snake()
+///////////////////////////////////////////////////////////////////////////////
+void analisis()  // Verifica la siguiente fila para saber si se puede desplazar 
 {
+int i;
+uint8_t a;
        
-    uint8_t vt1[8]={1,3,7,0xf,0x1f,0x3f, 0x7f,0xff};
-    uint8_t vt2[8]={0b10000000,0b11000000,0b11100000,0b11110000,0b11111000,0b11111100,0b11111110,0b11111111};
-      
-    int j, i;
-      //reset
-    clr_vcol();
-    for (j=0; j<8;j++){
-        printMatrix(vt2);
-        for (i=0; i<8;i++){
-            if(j % 2 == 0){
-                vcol2[j]=vt1[i];
-            }else{
-                vcol2[j]=vt2[i];
+       for(i=0;i<tamano;i++)
+       {
+            a=screen[posicion-i] & mascara;
+            a= a & ((screen[posicion-i]>>1) & ~(mascara-1));
+           
+            if(mascara==a)
+            {
+             i=tamano;
+             verifica=1;
+            }  
+            else
+            {
+            verifica=0;       
             }
-            printMatrix(vcol2);
-            wait_ms(5);
-        }
-        }    
-}   
-int main() {
-                    uint8_t vcol[8]={0,0,0,0,0,0,0,0};
-                    sendSPI(0x0c,1);
-                    sendSPI(0x0F,1);
-                    wait_ms (500);
-                    sendSPI(0x0F,0);
-                    wait_ms (500);
-                    int i =0;
-                    int col=0;
-                    int val =0x55;
-                    while(1){
-                        col=+1;
-                        val=~val;
-                        sendSPI(0x1,val);
-                        wait(0.5);
-                        sendSPI(0x2,~val);
-                        wait(0.5);
-                        sendSPI(0x55,val);
-                        if (col>8)
-                            col=0;
-                     //   print_Snake();
-                        }
+       }  
+} 
+//////////////////////////////////////////////////////////////////////////////
+void nuevo () //pide nuevamente los datos de la pieza con los cambios de giro o posicion
+{
+   int k;
+  
+    for(k=0;k<tamano;k++)//borra la pieza que habia 
+    {   
+      screen[posicion-k]=screen[posicion-k]&(mascara-1);
+    }
+    mascara=128;//se coloca 128 para que baje completa la pieza
+    tamano=0;
+    posicion=posicion_original;
+        
+        switch(pieza)//vuelve a colocar los datos de la pieza con los cambios
+             {                          
+                   case 0: a(giro);   break;                       
+                   case 1: b(giro);   break;  
+                   case 2: c(giro);   break; 
+                   case 3: d(giro);   break;  
+                   case 4: e(giro);   break;  
+                   case 5: f(giro);   break; 
+                   case 6: g(giro);   break;  
+                   default: pc.printf("Error en figura \n");
+             } 
+
+}         
+//////////////////////////////////////////////////////////////////////////////
+int analisis2()//INTENTO DE RESTRINGIR EL GIRO
+{   
+   int b;
+   
+   if(mascara<=((screen[posicion-1])+1) || mascara<=((screen[posicion+tamano])+1))  
+   {
+      b=0;
+   } 
+   else 
+   {
+      b=1;
+   }
+   
+   return b;
+}    
+//////////////////////////////////////////////////////////////////////////////
+void giros() //interrupcion cuando se oprime el boton de giro 
+{
+ int girox,posicionx;
+ int a=1;
+ int b=1;
+ 
+ cambio=1;//entra al cambio de velocidad para la visualizacion dinamica
+ mascarax=mascara;   //guarda la posicion de donde estaba la pieza que es hasta donde se debe hacer la visualizacion 
+ girox=giro;
+ posicionx=posicion_original;
+                
+   giro=giro+1;
+   if(giro>=4) giro=00;//limita el giro 
+   b=analisis2();//LA IDEA ES QUE AQUI ANALICE SI PUEDE GIRARSE
+   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
+   a=ubicacion();
+   if (a==0 | b==0)///cuando esta fuera de los limites vuelve a mandar los mismos datos de la pieza que estaba
+   {
+     giro=girox;
+     posicion_original=posicionx;
+  }
+  nuevo();   //se pide esta funcion nuevamente porque en dado caso de que no este en lo limites se vuelvan a enviar los mismos datos
+  
+  wait_ms(700);
 }
-// ***************************************************************************
-// option two: use maz7219 library
+//////////////////////////////////////////////////////////////////////////////
+void pmenos()    //interrupcion de poscion menos
+{
+  int girox,posicionx;
+  int a=1;
+  int b=1;
+
+  cambio=1;//entra al cambio de velocidad para la visualizacion dinamica
+  mascarax=mascara;   //guarda la posicion de donde estaba la pieza que es hasta donde se debe hacer la visualizacion 
+  girox=giro;
+  posicionx=posicion_original;
 
-// ***************************************************************************    
-/*
-Max7219 deviceM(PB_15, PB_14, PB_13, PB_12);
-
+  posicion_original=posicion_original-1;
+  b=analisis2();//LA IDEA ES QUE AQUI ANALICE SI PUEDE CORRERSE 
+  a=ubicacion();
+  if (a==0 | b==0)//cuando esta fuera de los limites vuelve a mandar los mismos datos de la pieza que estaba
+  {
+     giro=girox;
+     posicion_original=posicionx;
+  }
+  nuevo();// solo se solicita una vez esta funcion ya que lo unico que varia es la posicion 
+  wait_ms(500);
+}    
+//////////////////////////////////////////////////////////////////////////////
+void pmas() //interrupcion posicion mas
+{
+  int girox,posicionx;
+  int a=1;
+  int b=1;
+  
+  cambio=1;//entra al cambio de velocidad para la visualizacion dinamica
+  mascarax=mascara; //guarda la posicion de donde estaba la pieza que es hasta donde se debe hacer la visualizacion  
+  girox=giro;
+  posicionx=posicion_original;
+  
+  posicion_original=posicion_original+1;  
+  b=analisis2();//LA IDEA ES QUE AQUI ANALICE SI PUEDE CORRERSE
+  a=ubicacion();
+  
+  if (a==0 | b==0)//cuando esta fuera de los limites vuelve a mandar los mismos datos de la pieza que estaba
+  {
+      giro=girox;
+      posicion_original=posicionx;
+  }
+  nuevo();
+  wait_ms(500);
+}
+//////////////////////////////////////////////////////////////////////////////
+void play ()  // Funcion encargada de determinar el estado de la mascara
+{
+cambio=0;
+int a=1;
+mascara=128;
+velocidad=1;
+a=ubicacion();
 
-int main() {
-    
-    max7219_configuration_t cfg = {
-    .device_number = 1,
-    .decode_mode = 0,
-    .intensity = Max7219::MAX7219_INTENSITY_8,
-    .scan_limit = Max7219::MAX7219_SCAN_8
-};
-   
-    deviceM.init_device(cfg);
-    
-    deviceM.enable_device(1);
-   
-    deviceM.set_display_test();
-    wait(1);   
-   deviceM.clear_display_test();
-    wait(1);
-  
-    while(1){
-         deviceM.write_digit(1,8,0b11111111);
-         deviceM.write_digit(1,1,0b01010101);
-         deviceM.write_digit(1,2,0b10101010);
-         deviceM.write_digit(1,3,0b01010101);
-         deviceM.write_digit(1,4,0b10101010);
-         deviceM.write_digit(1,5,0b01010101);
-         deviceM.write_digit(1,6,0b10101010);
-         deviceM.write_digit(1,7,0b01010101);
-        }
+    while(a==1)
+    {   
+        analisis();
+          
+        if (verifica==1)a=0;
+        else 
+        {   
+                             
+           if(cambio==1)//cambio de velocidad para poder hacer visualizacion dinamica cada vez que se presiona un pulsador
+            {
+                if(mascarax!=mascara)velocidad=0;//mientras cae a la posicion que estaba va a tener esta velocidad
+                else 
+                {
+                    velocidad=1;  
+                    cambio=0;
+                 }   
+            } 
+            else velocidad=1;
+            
+            girop.rise(&giros);//interrupcion giro
+            posicionmenos.rise(&pmenos);//interrupcion posicion menos
+            posicionmas.rise(&pmas);//interrupcion posicion mas
+            
+            escribir();  
+            mascara=mascara/2; 
+            wait(velocidad);
+            }
+    }     
 }
-*/
\ No newline at end of file
+///////////////////////////////////////////////////////////////////////////////         
+int main() { // fucnion principal 
+ 
+        sendSPI(0x0c,1);
+        sendSPI(0x0F,1);
+        wait (1);
+                    
+        sendSPI(0x0F,0);
+        wait (1);
+        sendSPI(0xB,0x7);
+        borrar();
+        int inicio,fin; 
+        
+          while(1){
+           //pide los datos por el serial
+           inicio=pc.getc();                   
+           pieza = pc.getc(); 
+           giro=pc.getc();
+           posicion=pc.getc();     
+           fin=pc.getc();           
+                       
+                       if((inicio==60) && (fin==62))
+                       {
+                               switch(pieza)
+                               {                          
+                                      case 0: a(giro); play();  break;                       
+                                      case 1: b(giro); play();  break;  
+                                      case 2: c(giro); play();  break; 
+                                      case 3: d(giro); play();  break;  
+                                      case 4: e(giro); play();  break;  
+                                      case 5: f(giro); play();  break; 
+                                      case 6: g(giro); play();  break;  
+                                      default: pc.printf("Error en figura \n");
+                               }     
+                        }                       
+         } 
+} 
\ No newline at end of file