File content as of revision 2:142a1071fcc7:

#include "mbed.h"
#include "MPU6050.h"
#include "figs.h" 
Ticker bajar;
Ticker cambi;
Ticker dere;
Ticker izqui;
Serial command(USBTX,USBRX);
AnalogIn joy(A0);
AnalogIn joy1(A1); 
float vx=0;
float vy=0;
DigitalIn cambios(PB_8);
int cc=0, punto=1;
uint8_t movimiento=0;
float VEL= 500; 
uint8_t matrix_act [11]={0,0,0,0,0,0,0,0,0,0,0};   
uint8_t matrix_temp [8]={0,0,0,0,0,0,0,0};    
uint8_t matrix_temp1[8]={0,0,0,0,0,0,0,0};
uint8_t fila=1,cont=0,columna=1,rotacion=1,figura=0;
SPI deviceM(PB_15, PB_14, PB_13);
DigitalOut ssel (PB_12);
Serial a(USBTX,USBRX);
//Ticker cambio;
MPU6050 Wire(PB_9,PB_8);
InterruptIn iz(PA_14);
InterruptIn de(PA_13);
#define  uint8_t unsigned char
float q[3];
int pos;
float vel=200;
int b;
uint8_t cam[3]={0b01100000,0b00011000,0b00000110};
uint8_t Matr[9]={0,0,0,0,0,0,0,0,0};
uint8_t entorno={0b10000001};
uint8_t carro={0b00011000};
uint8_t obs=0b01100000;
void derecha();
void izquierda(); 
void colision();
void juego();
void accelerometro();
void cambio();
void vell();
void carro_juego();
void print_matrix(uint8_t *temp);
int con;
int az;

void sendSPI(uint8_t d1, uint8_t d2)
{
    deviceM.unlock();
    ssel=0;
    deviceM.write(d1); 
    deviceM.write(d2);  
    ssel=1;
    deviceM.lock(); 
}
   
void borrar()
{
 for(int i;i<=8;i++)   {
     sendSPI(i,0);
     }
}
///////////////////////////////////////
void inicializar(){
                    a.baud(9600);
                    sendSPI(0x0c,1);
                    sendSPI(0x09,0);
                    sendSPI(0x0A,0x01);
                    sendSPI(0x0F,1);
                    wait (0.5);
                    sendSPI(0x0F,0);
                    wait(0.5);
                    sendSPI(0xB,0x7);    
                    borrar();
                    vel=200;
                    carro=0b00011000;
    }
//////////////////////////////////////////
void imprimir()
{
    int c_d; //carro, obstaculo y entorno
    int c_e; //carro y entorno
    int din;
    for(int i=1;i<=7;i++){
             sendSPI(i,entorno);
              }
   for(int j=1;j<=10;j++){
             din=(obs>>b) | entorno  ;
             c_d= carro | din;
             c_e=carro | entorno;
             sendSPI(8,c_e);
             if(j<=7){   
             sendSPI(j,din);
             }
             
             if(j>1 && j<=8)
             sendSPI(j-1,din);
                 
             if(j>2 && j<=9){
             sendSPI(j-2,entorno);
             }
             if(j>=8&&j<=9){
                 sendSPI(8,c_d);
                 }
             if(j>10){
                 sendSPI(8,c_e);
                 }
            
             if( (obs>>b)==carro && j==8 ){
               colision();
                 }
             accelerometro();
             cambio();
             wait_ms(vel);
    }
}
//////////////////////////////////////////
void carro_juego() {
     while(1){
     juego();        
        }
}
///////////////////////////////////////////
void juego(){
                    inicializar();   
                    //de.rise(&derecha);  
                    //iz.rise(&izquierda);  
                    a.printf("inicio\n");
                    while(1){
                    b=2*(rand()%3);
                    a.printf("umero %d\n",az);
                    imprimir();
                    vell();  
                    }
             }
///////////////////////////////////
void derecha()
{
    if(carro==0b00011000 || carro==0b01100000)
    carro=carro>>2;
    a.printf("entra der \n");
    return;
}
///////////////////////////////////
void izquierda()
{
    if( carro==0b00000110 ||  carro==0b00011000  )
    carro=carro<<2;
    a.printf("entra izq \n");
    return;
}
////////////////////////////////////
void cambio(){
    switch(az){
        case 1: carro = cam[0];break;
        case 2: carro = cam[1];break;
        case 3: carro = cam[2];break;
        default: break;}
    
    }
////////////////////////////////////
void colision ()
{
                 borrar();  
                 sendSPI(0x0F,0);
                 sendSPI(3,0b01111110);
                 sendSPI(4,0b01111110);
                 sendSPI(5,0b01111110);
                 sendSPI(6,0b01111110);
                 con=0;
                 vel=200;
                 wait(2);
                 juego();
}
/////////////////////////////////////
void accelerometro(){
         Wire.getAccelero(q);
         a.printf("accelero: \t x=  %f,\t y=  %f, \t z= %f \n",q[0],q[1],q[2]);
         int valor=q[1];
         if(valor<=(-4) && valor>=(-10)){
           az=1;}
         if(valor<(4) && valor>=(-4)){
           az=2;}
         if(valor<(10) && valor>=(4)){
           az=3;}
         a.printf("az : \t  %d \n",az);
    }
/////////////////////////////////////
void vell(){
    con++;
    if(con>2 && vel>=20)
    {
    vel=vel-(vel*0.2);
    }
    }
    
    /////////////////////////////////////////////////////////////////////////////////////
    
    

void init_display()
{
    sendSPI(0x0c,1);
    sendSPI(0x0b,7);
    sendSPI(0x09,0);
    sendSPI(0x0A,0x0E);
    int j;
    for (j=0;j<4;j++){
        sendSPI(0x0F,1);
        wait (0.2);
        sendSPI(0x0f,0);
        wait (0.2);
    }   
}

void copy_matrix(uint8_t a,uint8_t b,uint8_t c,uint8_t* fig,uint8_t columna)
{       
        if(((matrix_act[cont-2]& *(fig+c)>>columna-1)==0)&&((matrix_act[cont-1]& *(fig+b)>>columna-1)==0)&&((matrix_act[cont]& *(fig+a)>>columna-1)==0)){
                    matrix_temp[0]= *(fig+5)>>columna-1;             
                    matrix_temp[1]= *(fig+a)>>columna-1;            
                    matrix_temp[2]= *(fig+b)>>columna-1;
                    matrix_temp[3]= *(fig+c)>>columna-1;
        }   
}

void borraraa()            
{
    int i;
    for(i=0;i<=8;i++)
    {
        sendSPI(i,0);
        matrix_act[i]=0;   
    }
};

void game_over()
{
    uint8_t go [9]={0,0,0b01000010,0b00100100,0b00011000,0b00100100,0b01000010,0b00000000,0}; 
    int k,n;
    for(n=0;n<6;n++)
    {
    borraraa();
    for(k=1;k<=8;k++)
    {
    sendSPI(k,go[k]);
    }
    wait(0.2);
    borraraa();
    wait(0.2);
    }
    }
    

void buscar_fila(){
    for (uint8_t i=0;i<9;i++){                     
        if((matrix_act[i]& matrix_temp[3])==0){
        fila=i;
        }
        if(((matrix_act[i]& matrix_temp[3])!=0)&& (i!=9)){
        fila=i-1;  
        command.printf("Fila pos 1: %d \n", fila);                                
        i=9;
        }
        if(((matrix_act[i]& matrix_temp[2])!=0)&& (i!=9)){           
        fila=i;                                   
        i=9;
        command.printf("Fila pos 2: %d \n", fila);
        }
        if(((matrix_act[i]& matrix_temp[1])!=0)&& (i!=9)){
        fila=i+1;                                 
        i=9;
        command.printf("Fila pos 3: %d \n", fila);
        }
    }
    if(fila>8)
        fila=8;
    if(fila<=1){
        punto=1;
        VEL=500;
        wait_ms(VEL);
        game_over();
        borraraa();
        fila=8;
    }
};

void guardar(){
        matrix_act[fila-3]=matrix_temp1[0];
        matrix_act[fila-2]=matrix_temp1[1];
        matrix_act[fila-1]=matrix_temp1[2];
        matrix_act[fila  ]=matrix_temp1[3];
        };
    
void reada()
{    vx=0;
     vy=0;
     vx=joy.read();
     vy=joy1.read();
     //cc=cambio.read();
    }
    
void bajaf()
{
    movimiento=4;
}
void arr()
{ 
    if (vy<0.2)
    movimiento=1;
}
void der()
{ 
    if (vx>0.8)
    movimiento=2;
}
void izq()
{ 
    if (vx<0.2)
    movimiento=3;
}
void movimiento_fig(){
    reada();
    command.printf("vy = %f \n", vy);
    command.printf("vx = %f \n", vx);
    //command.printf("cc = %f \n", cambio.read());
   if(vy<0.2)  
    movimiento=1;
    if(vy>0.8)  
    movimiento=4;
    if(vx<0.2)
    movimiento=3;
    if(vx>0.8) 
    movimiento=2;
    command.printf("movimiento = %d \n", movimiento);
    switch (movimiento){
                
                case 4:
                cont++;
                //printf("%f", joy.read());
                if(cont>8)cont=8;
                break;                                            
                
                case 1:
                if( (matrix_temp[1]==2) || (matrix_temp[1]==1)|| (matrix_temp[1]==3)) 
                columna--;
                rotacion++;
                if(rotacion>4)
                rotacion=1;
                break; 
                
                 case 2:
                if((matrix_temp[2]==7 || matrix_temp[3]==7)||(matrix_temp[2]==3 && matrix_temp[3]==6)) {
                    command.printf("a");
                    columna=6;
                    }
                else if((matrix_temp[1]==2 && matrix_temp[2]==2 && matrix_temp[3]==2)){
                    command.printf("b");
                    columna=8;
                    }
                else if (columna<7){
                    command.printf("c");
                    columna++;
                    }
                    //printf("%f", joy1.read());
                break;        
            
                case 3:
                columna--;
                if(columna<1)
                columna=1;
                //printf("%f", joy.read());
                break;                                       
                                                        
    }
    }


void print_matrix(uint8_t *temp){
            matrix_temp1[0]=(matrix_temp[0]+ matrix_act[cont-3]);
            matrix_temp1[1]=(matrix_temp[1]+ matrix_act[cont-2]);
            matrix_temp1[2]=(matrix_temp[2]+ matrix_act[cont-1]);
            matrix_temp1[3]=(matrix_temp[3]+ matrix_act[cont]);                              
            sendSPI(cont-3,matrix_temp1[0]);
            sendSPI(cont-2,matrix_temp1[1]);
            sendSPI(cont-1,matrix_temp1[2]);
            sendSPI(cont  ,matrix_temp1[3]);                     //pasa de i+2 a i+1
            if(punto%4==0)
            {
            VEL=VEL/3;
             if(VEL<=50)
             VEL=50;   
                }
            wait_ms(VEL);
}

void crear_fig(char type_fig,char rotacion,char columna)
{    
    switch (type_fig){                  
        case 1: if(columna>7)
                columna=7;
                copy_matrix(5,1,1,PLANT,columna); break;  
        
        case 2: if(rotacion==1 || rotacion==3)              
                copy_matrix(0,0,0,PLANT,columna);
                if(rotacion==2 || rotacion==4)
                copy_matrix(5,5,2,PLANT,columna);         
                break;
                  
        case 3: if(rotacion==1)
                copy_matrix(0,0,1,PLANT,columna);        
                if(rotacion==2)
                copy_matrix(5,2,0,PLANT,columna);
                if(rotacion==3)
                copy_matrix(1,3,3,PLANT,columna);
                if(rotacion==4)
                copy_matrix(5,6,2,PLANT,columna);
                break;
        
        case 4: if(rotacion==1)
                copy_matrix(5,3,2,PLANT,columna);        
                if(rotacion==2)
                copy_matrix(0,1,0,PLANT,columna);
                if(rotacion==3)
                copy_matrix(5,2,3,PLANT,columna);
                if(rotacion==4)
                copy_matrix(3,1,3,PLANT,columna);
                break;
        
        case 5: if(rotacion==1 || rotacion==3)
                copy_matrix(5,4,1,PLANT,columna);   
                if(rotacion==2 || rotacion==4)
                copy_matrix(0,1,3,PLANT,columna);
                break; 
    }  
}

void figuras(){
    figura= rand() % 5+1; 
    rotacion= rand() % 4+1;
    columna= 4; 
    }
    
void elimina_linea(){
   for(uint8_t i=0;i<9;i++){
        if(matrix_act[i]==255){
            for(uint8_t a=i;a>=1;a--){
                sendSPI(a,matrix_act[a-1]);
                matrix_act[a]=matrix_act[a-1];
            }
            punto++;
            printf("%f", punto);
        }
    }
}

int tetris() {
    bajar.attach(&bajaf, 0.1);
    init_display();
    borraraa();
    cambi.attach(&arr,0.1);
    dere.attach(&der,0.1);
    izqui.attach(&izq,0.1);
    while(1){
            figuras();
            buscar_fila();
            cont=0; 
            elimina_linea();
            while (cont<fila){
                        movimiento_fig();    
                        crear_fig(figura,rotacion,columna);
                        buscar_fila();
                        print_matrix(matrix_temp);
                        }          
            guardar();
        }
    }
    //////////////////////////////////////////////////////////////////////////////////////////////
    
    void hacer_carita()
    {
    int k;
    uint8_t carita[8]={0b00000000, 0, 0b00100100,0b00100100,0,0, 0b01000010,0b00111100};
                for(k=1;k<=8;k++)
        {
        sendSPI(k ,carita[k]);}
        }
    void inicializar_menu(){
    sendSPI(0x0c,1);
    sendSPI(0x0b,7);
    sendSPI(0x09,0);
    sendSPI(0x0A,0x0E);
    int j=0;
    for (j=0;j<4;j++){   
        hacer_carita();
        wait (0.2);
        borraraa();
        wait (0.2);
    }  
    }
    
void eleccion_tetris()
{
    int k;
    uint8_t elec[8]={0b00000000, 0,0, 0b00000000,0b11010011,0b11011010,0b00001010, 0};
                for(k=1;k<=8;k++)
        {
        sendSPI(k ,elec[k]);}
       /* reada();
        if(vx>0.6){
        borraraaaaaa();
        carro_juego();}
        }*/
        }
     
void eleccion_carrito()
{
        int k;
    uint8_t elec1[8]={0b00000000, 0,0,0b00111000,0b01111100,0b00101000, 0, 0b11111111};
                for(k=1;k<=8;k++)
        {
        sendSPI(k ,elec1[k]);}
        /*reada();
        if(vx>0.6){
        borraraaaaaa();
        tetris();}*/
        }
    
    int main() 
{   int game=0;
    int pant=1;
    borraraa();
    inicializar_menu();
    //eleccion_tetris();
    while(1)
    {
    game=0;
    reada();
    if(vy<0.48)  
    game=1;
    if(vy>0.58)  
    game=2;
    
    switch(game)
    {
        case 1:
        pant++;
        if(pant%2!=0)
        {borraraa(); 
        eleccion_tetris();
        if(vx>0.6){
        borraraa();
        carro_juego();}
        }        
        if(pant%2==0)
        {borraraa();
        eleccion_carrito();
        if(vx>0.6){
        borraraa();
        tetris();}
        }
        break;
        
        case 2:
        pant++;
        if(pant%2!=0)
        {borraraa();
        eleccion_tetris();
        if(vx>0.6){
        borraraa();
        carro_juego();}
        }
        if(pant%2==0)
        {   borraraa();
            eleccion_carrito();
        if(vx>0.6){
        borraraa();
        tetris();}
        }
        break;
        }
        //printf(" pantalla %d \n", pant);
        wait(0.5);
        //printf("entra a %d \n", game);
        //wait(1);
        //printf(" vx %f \n", vx);
        
    }
    }
        
    
    /*
    wait(1);
    borraraaaa();
    eleccion_carrito();
    wait(1);*/