Revision 6:eadec7d43859, committed 2018-11-21

Comitter:

jiuk

Date:

Wed Nov 21 15:57:09 2018 +0000

Parent:

5:1292da7b7c6f

Commit message:

Version 21-11 previa cambios.

Changed in this revision

diff -r 1292da7b7c6f -r eadec7d43859 recoge_manzanas.cpp
--- a/recoge_manzanas.cpp	Tue Nov 20 08:30:45 2018 +0000
+++ b/recoge_manzanas.cpp	Wed Nov 21 15:57:09 2018 +0000
@@ -1,11 +1,10 @@
 // Read from I2C slave at address 0x62
 
 #include "mbed.h"
-
 #include "MPU6050.h"
 
 Serial command(USBTX,USBRX);        //habilitar la comunicacion serial a traves del puerto usb.
-MPU6050 Wire(PB_9 , PB_8 ); 
+MPU6050 Wire(PB_9 , PB_8); 
 
 SPI deviceM(PB_15, PB_14, PB_13);
 DigitalOut ssel (PB_12);
@@ -14,13 +13,13 @@
 //Serial command(USBTX,USBRX);        //habilitar la comunicacion serial a traves del puerto usb.
 Serial com_tar(PC_10,PC_11);        //master f446R
 //Serial com_tar(PA_15,PB_7);       //slave f411R        //habilitar la comunicacion serial a traves del puerto usb.
-Ticker timer;
+Ticker timer, timer_1;
 DigitalIn pulsador(PH_1);
 AnalogIn in1(PC_2);
 AnalogIn in2(PC_3);
 DigitalOut led(LED1);
 
-#define  VEL 200                     //Velocidad de actualizacion de dato en el controlador.
+#define  VEL 400                     //Velocidad de actualizacion de dato en el controlador.
 #define  MIN 1
 #define  MAX 8
 #define  MINC 128
@@ -31,11 +30,325 @@
 
 int columna=1, manzanas=0, fila=1, fil=1, colum=0;
 uint8_t _guarda_manzanas[8]={0,0,0,0,0,0,0,0};
+uint8_t mat_act[11]={0,0,0,0,0,0,0,0,0,0,0};    //Matriz para mostrar en pantalla.
+uint8_t mat_tmp1[8]={0,0,0,0,0,0,0,0};
+uint8_t cont=0, correr=0, metrix=0,type_fig=0,reset=0;
+uint8_t ncolumna=1,grados=1,ficha=0;
+uint8_t mat_tmp[8]={0,0,0,0,0,0,0,0};           //Matriz temporal para arrojar las fichas.
+                    //   0     ,   1      ,   2      ,  3       ,    4     ,5,   6
+uint8_t FIG_ALL[8]={0b10000000,0b11000000,0b11100000,0b01000000,0b01100000,0,0b00100000};//FIG_C[0]=1; FIG_C[1]=11; FIG_C[2]=111; FIG_C[3]=01; FIG_C[4]=011
+
 bool _boton=0;
 void blink();
 void boton();
 void guarda_manzana();
 void imprime_manzanas();
+void cop_mat(uint8_t,uint8_t,uint8_t,uint8_t);
+void borrar();
+void dibujar();
+void buscar_fil();
+void guardar_mat();
+void correr_fig();
+void imp_mat();
+void fichas();
+void buscar_linea();
+void revisar_mov();
+void manzanas_revisar_mov();
+void cambiar_jugador();
+void sendSPI(uint8_t, uint8_t);
+void buscador();
+int main ();
+
+//--------------------------------------------------
+//-------------------BUSCAR_FILA------------------------
+//--------------------------------------------------
+void buscar_fil(){
+    for (uint8_t i=0;i<9;i++){                     
+        if((mat_act[i]& mat_tmp[3])==0){
+        fila=i;
+        //command.printf("\n1- comparacion inicial:\n %d",mat_act[i]& mat_tmp[2]);
+        }
+        if((mat_act[i]& mat_tmp[3])!=0){
+        fila=i-1;                                   //cambio de 2 a 1
+        i=9;
+        //command.printf("\n2- comparacion mat_act[i]& mat_tmp[2] :\n %d",mat_act[i]& mat_tmp[2]);
+        }
+        if((mat_act[i]& mat_tmp[2])!=0){            //se condicionan las salidas de la busqueda de lanueva fila
+        fila=i;                                   //cambio de 2 a 1
+        i=9;
+        //command.printf("\n3- comparacion mat_act[i]& mat_tmp[1] :\n %d",mat_act[i]& mat_tmp[1]);
+        }
+        if((mat_act[i]& mat_tmp[1])!=0){
+        fila=i+1;                                   //cambio de 2 a 1
+        i=9;
+        //command.printf("\n4- comparacion mat_act[i]& mat_tmp[0]:\n %d",mat_act[i]& mat_tmp[0]);
+        }
+    }
+    if(fila>8)
+        fila=8;
+    if(fila<=1){
+        wait_ms(VEL);
+        borrar();
+        fila=8;
+    }
+    command.printf("\n buscar fila \n %d",fila);
+    command.printf("\n ******************************* \n ");
+};
+
+
+//--------------------------------------------------
+//-------------------GUARDAR_MATRIZ------------------------
+//--------------------------------------------------
+void guardar_mat(){
+        for (uint8_t i=0;i<9;i++){
+            mat_act[fila-(8-i)]=mat_tmp1[i];
+            }
+        };
+
+
+//--------------------------------------------------
+//-------------------CORRER_FIGURA------------------------
+//--------------------------------------------------        
+void correr_fig(){
+    
+    uint8_t correr=command.getc();
+    
+    if(correr==30)  //Arriba, voltear figura.
+    correr=1;
+    
+    else if(correr==29)  //izquierda, correr la figura.
+    correr=2;
+    
+    else if(correr==28)  //Derecha correr la figura.
+    correr=3;
+    
+    else if(correr==31)  //bajar, baja la figura.
+    correr=0;
+    command.printf("\n correr fig \n %d",correr);
+    revisar_mov();
+    }
+
+
+//--------------------------------------------------
+//-------------------IMPRIMIR_MATRIZ------------------------
+//--------------------------------------------------    
+void imp_mat(){                                 //se genera la variable global cont.
+            mat_tmp1[0]=(mat_tmp[0]+ mat_act[cont-3]);
+            mat_tmp1[1]=(mat_tmp[1]+ mat_act[cont-2]);
+            mat_tmp1[2]=(mat_tmp[2]+ mat_act[cont-1]);
+            mat_tmp1[3]=(mat_tmp[3]+ mat_act[cont]);         //condicionador de funcion, se descarta por una funcion smart.                     
+            sendSPI(cont-3,mat_tmp1[0]);
+            sendSPI(cont-2,mat_tmp1[1]);
+            sendSPI(cont-1,mat_tmp1[2]);
+            sendSPI(cont  ,mat_tmp1[3]);                     //pasa de i+2 a i+1
+            wait_ms(VEL);
+}
+
+
+//--------------------------------------------------
+//-------------------DIBUJAR_FICHAS------------------------
+//--------------------------------------------------
+void dibujar()
+{    
+    switch (ficha){                  //Se envia el vector que contiene la figura a la funcion copiar matriz.
+        case 1: if(ncolumna>7)
+                ncolumna=7;
+                cop_mat(5,1,1,ncolumna); 
+                break;  //1: cuadro;
+        
+        case 2: if(grados==1 || grados==3)              
+                cop_mat(0,0,0,ncolumna);
+                if(grados==2 || grados==4)
+                cop_mat(5,5,2,ncolumna);         //2: I;    
+                break;
+                  
+        case 3: if(grados==1)
+                cop_mat(0,0,1,ncolumna);         //3: L; 
+                if(grados==2)
+                cop_mat(5,2,0,ncolumna);
+                if(grados==3)
+                cop_mat(1,3,3,ncolumna);
+                if(grados==4)
+                cop_mat(5,6,2,ncolumna);
+                break;
+        
+        case 4: if(grados==1)
+                cop_mat(5,3,2,ncolumna);         //4: T;
+                if(grados==2)
+                cop_mat(0,1,0,ncolumna);
+                if(grados==3)
+                cop_mat(5,2,3,ncolumna);
+                if(grados==4)
+                cop_mat(3,1,3,ncolumna);
+                break;
+        
+        case 5: if(grados==1 || grados==3)
+                cop_mat(5,4,1,ncolumna);   //5: S; 
+                if(grados==2 || grados==4)
+                cop_mat(0,1,3,ncolumna);
+                break;      
+    }  
+}
+
+
+//--------------------------------------------------
+//-------------------FICHAS_RANDOM------------------------
+//--------------------------------------------------
+void fichas(){
+    ficha= rand() % 5; 
+    }
+
+
+//--------------------------------------------------
+//-------------------BUSCAR_LINEA------------------------
+//--------------------------------------------------    
+void buscar_linea(){
+    for(uint8_t i=0;i<9;i++){
+        if(mat_act[i]==255){
+            for(uint8_t a=i;a>=1;a--){
+                sendSPI(a,mat_act[a-1]);
+                mat_act[a]=mat_act[a-1];
+            }
+        }
+    }
+}
+
+
+//--------------------------------------------------
+//-------------------REVISAR_MOVIMIENTO------------------------
+//--------------------------------------------------
+void revisar_mov(){
+    command.printf("\n correr:\n %d",correr);
+    switch (correr){
+                
+                case 0:
+                cont++;
+                if(cont>8)cont=8;
+                break;                                                    //cae la figura;
+                
+                case 1:
+                if((mat_tmp[1]==2) || (mat_tmp[1]==1) || (mat_tmp[1]==3)) //faltan condiciones para evitar desplazamiento innecesario.
+                ncolumna--;
+                grados++;
+                if(grados>4)
+                grados=1;
+                break;                                                    //Girar la figura;
+                
+                case 2:
+                if((mat_tmp[1]!=1) && (mat_tmp[2]!=1) && (mat_tmp[3]!=1)){
+                    if((mat_tmp[1]!=3) && (mat_tmp[2]!=3) && (mat_tmp[3]!=3)){
+                        if((mat_tmp[1]!=7) && (mat_tmp[2]!=7) && (mat_tmp[3]!=7))
+                        ncolumna++;
+                        }
+                    }
+                command.printf("\n columna:\n %d",ncolumna);
+               
+                break;                                                    //correr a la Derecha;
+                
+                case 3:
+                ncolumna--;
+                command.printf("\n columna:\n %d",ncolumna);
+                if(ncolumna<1)
+                ncolumna=1;
+                break;                                                    //correr a la izquierda;
+                /*
+                case 4:
+                cont++;
+                if(cont>8)cont=8;
+                break; 
+                */
+            }  
+    } 
+
+
+//--------------------------------------------------
+//-------------------ESCOGER_JUEGO------------------------
+//--------------------------------------------------   
+int escoger_juego(){
+    uint8_t escoger=0;
+    float _acc[3];
+    int acc[3],buscado=32;  
+    while(escoger==0)
+    {
+        ncolumna=3;
+        cont=3;
+        ficha=4;
+        dibujar();
+        imp_mat();
+        guardar_mat();
+        //////////////////
+        sendSPI(7,36);
+        //wait(0.5);
+        if(_boton==1) 
+            {
+                Wire.getAccelero(_acc);
+                acc[0]=((int)_acc[0])+2;
+                acc[1]=((int)_acc[1])+2; 
+            }
+        else
+            {
+                int x=((int)(in1.read()*-650))+13;
+                int y=((int)(in2.read()*-650))+13;
+                acc[0]=x;
+                acc[1]=y;
+                //command.printf("Joystick: \t X= %d, \t Y= %d, \n", x,y);     
+            }
+        if(acc[0]>GIRO)            //eje x derecha
+            {
+                correr=30;
+                command.printf("\nJoystick: correr= %d, \n", correr);
+            }          
+        else if(acc[0]<-GIRO)   //eje x izquierda
+            {
+                        correr=31;
+                command.printf("\nJoystick: correr= %d, \n", correr);
+            }
+        if(correr==30)
+            {
+                grados= rand() % 4;
+                ficha= rand() % 5;
+                ncolumna=ncolumna++;
+                cont=3;
+                dibujar();
+                imp_mat();
+                guardar_mat();
+                sendSPI(0,0);
+                sendSPI(1,0);
+                sendSPI(2,0);
+                sendSPI(3,0);
+                wait(0.1);
+                if(_boton==1)
+                escoger=1;
+                command.printf("\nTetris: escoger= %d, \n", escoger); 
+            }
+        else if(correr==31)
+            {
+                sendSPI(7,4+buscado);
+                wait(0.05);
+                sendSPI(7,buscado);
+                buscado=buscado>>1;
+                if(buscado==4)
+                buscado=32;
+                if(_boton==1)
+                escoger=2;
+                command.printf("\nRecoge_manzanas: escoger= %d, \n", escoger); 
+            }
+    }
+    return escoger;
+}
+
+//--------------------------------------------------
+//-------------------COPIAR_MATRIZ------------------------
+//--------------------------------------------------
+void cop_mat(uint8_t a,uint8_t b,uint8_t c,uint8_t columna)
+{       
+        if(((mat_act[cont-2]& FIG_ALL[c]>>columna-1)==0)&&((mat_act[cont-1]& FIG_ALL[b]>>columna-1)==0)&&((mat_act[cont]& FIG_ALL[a]>>columna-1)==0)){
+                    mat_tmp[0]= FIG_ALL[5]>>columna-1;             
+                    mat_tmp[1]= FIG_ALL[a]>>columna-1;            //Realiza una copia de la matriz actual fila por fila.
+                    mat_tmp[2]= FIG_ALL[b]>>columna-1;
+                    mat_tmp[3]= FIG_ALL[c]>>columna-1;
+        }   
+}
 
 //--------------------------------------------------
 //-------------------GUARDA_MANZANAS------------------------
@@ -48,19 +361,46 @@
 //--------------------------------------------------
 //-------------------TICKER------------------------
 //--------------------------------------------------  
-void attime() {
-    blink();
+void attime() 
+{
+    //blink();
     boton();
-    }; 
+};
+ 
+//--------------------------------------------------
+//-------------------TICKER_TETRIS------------------------
+//--------------------------------------------------  
+void attime_tetris() 
+{
+    //blink();
+    cont++;
+}; 
 
 //--------------------------------------------------
 //-------------------BOTON------------------------
 //--------------------------------------------------  
 void boton()
 {
-    if (pulsador == 0) 
+    uint8_t a=0;
+    if(reset==1)
+    reset=0;
+    while (pulsador == 0) 
         {
-            command.printf("Button pressed %b\n", _boton);
+            command.printf("Button pressed %d\n", a);
+            a++;
+            if (a>20)
+            {
+                for(int i=0;i<9;i++)
+                {
+                    borrar();
+                    wait(0.1);
+                    sendSPI(4,24);
+                    sendSPI(5,24);
+                    wait(0.1);
+                }
+                reset=1;
+            }
+            
             _boton= !_boton;
         }
 }  
@@ -129,16 +469,22 @@
 void generar_punto()
 {
     int col[8]={1,2,4,8,16,32,64,128};
+    borrar();
     int _fil=fil;
     fil= rand() % 7+1;
     int y= rand() % 7+1;
-    int colum=col[y];
+        command.printf("\n\n Fila: %d",fil); 
+    command.printf("\n Columna:%d",col[y]);
     if(_fil==fil)
-        _guarda_manzanas[fil]=colum+_guarda_manzanas[fil];
+        colum=colum+col[y];
+    colum=col[y];
+    if(fil==fila)
+    {
+        int guarda_linea=columna+colum;
+        sendSPI(fila,guarda_linea);
+    }
     else
-        _guarda_manzanas[fil]=colum;
-    command.printf("Generar_punto: %d\n", _guarda_manzanas[fil]);
-    imprime_manzanas();
+    sendSPI(fil,col[y]);
 }
 
 //--------------------------------------------------
@@ -152,9 +498,9 @@
 }
 
 //--------------------------------------------------
-//-------------------REVISAR_MOV------------------------
+//-------------------MANZANAS_REVISAR_MOV------------------------
 //--------------------------------------------------   
-void revisar_mov(uint8_t correr){
+void manzanas_revisar_mov(){
     //uint8_t guardar_linea=0;
     switch (correr)
     {
@@ -167,10 +513,9 @@
                 if (fila<MIN)
                 {
                     fila=MAX;
-                    uint8_t x=_guarda_manzanas[MIN];
                     sendSPI(MIN,0);
                 }
-                sendSPI(fila+1,0);
+                sendSPI(fila+1,_guarda_manzanas[fila+1]);
         break;
         
         case 4:
@@ -182,7 +527,7 @@
                     }
                 if (columna>MINC)
                     columna=MAXC;
-                sendSPI(fila-1,0);
+                sendSPI(fila-1,_guarda_manzanas[fila-1]);
         break;
         
         case 1:
@@ -194,7 +539,7 @@
                     fila=MAX;
                     sendSPI(MIN,0);
                     }
-                sendSPI(fila+1,0);
+                sendSPI(fila+1,_guarda_manzanas[fila+1]);
         break;
         
         case 3:
@@ -206,7 +551,7 @@
                     fila=MIN;
                     sendSPI(MAX,0);
                     }
-                sendSPI(fila-1,0);
+                sendSPI(fila-1,_guarda_manzanas[fila-1]);
         break;
         
         case 28:
@@ -227,7 +572,7 @@
                     fila=MAX;
                     sendSPI(MIN,0);
                     }
-                sendSPI(fila+1,0);
+                sendSPI(fila+1,_guarda_manzanas[fila+1]);
         break;
         
         case 31:
@@ -236,7 +581,7 @@
                     fila=MIN;
                     sendSPI(MAX,0);
                     }
-                sendSPI(fila-1,0);
+                sendSPI(fila-1,_guarda_manzanas[fila-1]);
         break;  
         
         case 0:
@@ -257,12 +602,12 @@
         {
                 if((acc[0]>(GIRO+x)) || (acc[0]<-(GIRO+x)) || (acc[1]>(GIRO+x)) || (acc[1]<-(GIRO+x)))
                     {
-                        vel=300; 
+                        vel=VEL/2; 
                         if((acc[0]>(GIRO+y)) || (acc[0]<-(GIRO+y)) || (acc[1]>(GIRO+y)) || (acc[1]<-(GIRO+y)))
-                            vel=100;
+                            vel=VEL;
                     }
                 else
-                    vel=500;   
+                    vel=VEL/3;   
         }
     return vel;
 }
@@ -277,7 +622,7 @@
     
 void buscador()
 {
-    uint8_t correr;
+    //uint8_t correr;
     int y=0,x=0,acc[3],v;
     float _acc[3];     
 
@@ -321,12 +666,11 @@
                     correr=28;
         else
         correr=0;
-        revisar_mov(correr);        
+        manzanas_revisar_mov();        
         v=velocidad(_acc);
         wait_ms(v);
 }
 
-
 //--------------------------------------------------
 //-------------------COMER------------------------
 //--------------------------------------------------   
@@ -367,32 +711,64 @@
 {
     int guarda_linea,x=0;
     timer.attach(&attime, 0.3);
+    timer_1.attach(&attime_tetris, 0.4);
     test();
-    borrar();
-    sendSPI(fila,columna);
-    generar_punto();
     while(1)
+    {
+        borrar();
+        int juego=escoger_juego();
+        if(juego==1)
+        {
+            while(reset==0)
+            {
+                //cambiar_jugador(); 
+                    fichas();
+                    buscar_fil();
+                    cont=0;
+                    // correr=command.getc();     //recibe el comando para orientar la ficha.
+                    while (cont<fila)
+                    {
+                            //cambiar_jugador(); 
+                            correr_fig();
+                            dibujar();
+                            buscar_fil();
+                            imp_mat();
+                            wait_ms(VEL);
+                    }       
+                    guardar_mat();
+                    buscar_linea(); 
+            } //fin while
+        }
+        else if(juego==2)
         {
-        buscador();
-        //validar_contrincante();
-            x=comer();
-            //command.printf("\n comer:\n %d",x);
-            if (x==0)
-                {
-                if(fil==fila){
-                        guarda_linea=columna+colum;
-                        sendSPI(fila,guarda_linea);
-                        }
-                else
+            sendSPI(fila,columna);
+            generar_punto();
+            while(reset==0)
+            {
+                buscador();
+                //validar_contrincante();
+                    x=comer();
+                    //command.printf("\n comer:\n %d",x);
+                    if (x==0)
                     {
-                        guarda_linea=columna;
-                        sendSPI(fila,guarda_linea);
-                        sendSPI(fil,colum);  
+                        if(fil==fila)
+                        {
+                                guarda_linea=columna+colum;
+                                sendSPI(fila,guarda_linea);
+                        }
+                        else
+                        {
+                                guarda_linea=columna;
+                                sendSPI(fila,guarda_linea);
+                                sendSPI(fil,colum);  
+                        }
                     }
-                }
-            else{
-                sendSPI(fila,columna);
-                }
-        //generar_punto();
+                    else
+                    {
+                        sendSPI(fila,columna);
+                    }
+                //generar_punto();
+            }
         }
+    }
 }
\ No newline at end of file