File content as of revision 0:b09782a64039:

#include "mbed.h"//biblioteca por defecto 
#include "algo.h"//biblioteca creada que contiene las figuras del juego de tetris
#define MAXDAT 3
Ticker anal;
AnalogIn vrx(A0);//puertos de entrada para lectura del joystick
AnalogIn vry(A1);//puertos de entrada para lectura del joystick
SPI deviceM(PB_15, PB_14, PB_13);//puertos usados para conectar la matriz
DigitalOut ssel (PB_12);//puertos usados para conectar la matriz
Serial pc(USBTX,USBRX);//conexion por puerto USB
 
int j=1,op;//variable puntero
double a=0.4;// variable que representa la velocidad del juego
int dir=0; //movimiento de la pelota: 0=derecha,1=izquierda
int up=0;  //movimiento de la pelota: 0=arriba,1=abajo
uint8_t FIG_J[6]={0x22,0x22,0xe2,0xa2,0xe7,0x0};//arreglo que contiene las iniciales T y P (iniciales de tetris y pin pon)
uint8_t FIG_U[8]={0xe7,0xa5,0xa7,0xa1,0xe7,0x0,0x0,0x0};//arreglo de 8 posiciones que contiene las iniciales de game over
uint8_t FIG_P[8]={0x38,0x10,0x0,0x0,0x0,0x0,0x0,0x0};//arreglo de 8 posiciones que contiene la barra y la pelota, cada bit representa los 8 leds de cada columna, ya el dexplazamiento de bit a bit representa los leds de las filas 
float mx;//variable donde se guarda los voltajes leidos
float msx;//variable donde se escalan los voltajes leidos
float my;//variable donde se guarda los voltajes leidos
float msy;//variable donde se escalan los voltajes leidos
void inicio();
void mostrar();
void mostrarg();
void mostrarj();
void borrar();
void barra();
void barra_ini();
void inicio();
uint8_t mat_act[11]={0,0,0,0,0,0,0,0,0,0,0};    //Matriz para mostrar en pantalla.
uint8_t mat_tmp[8]={0,0,0,0,0,0,0,0};
uint8_t mat_tmp1[8]={0,0,0,0,0,0,0,0};           //Matriz temporal de las fichas.
uint8_t dat[MAXDAT]={0,0,0};
uint8_t fila=0,save=0,i=0,cont=0,mcol=0,num=0,grad=0;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//FUNCIONES EN COMUN

void sendSPI(uint8_t d1, uint8_t d2)//envia datos a la tarjeta, cierra y abre puertos
{
    deviceM.unlock();
    ssel=0;
    deviceM.write(d1); 
    deviceM.write(d2);
    ssel=1;
    deviceM.lock();
}

void test()  //Test
{
    sendSPI(0x09,0);        //No decodificacion
    sendSPI(0x0B,0x07);     //Usa 8 leds                     
    sendSPI(0x0C,1);        //No se apaga
    sendSPI(0x0A,0x0);
        for (int i=0;i<2;i++)
        {
        sendSPI(0x0F,1);
        wait (0.1);
        sendSPI(0x0f,0);
        wait (0.1);    
        } 

}
void borrar() //borra toda la matriz;
{
    for(int i=0;i<=8;i++)//contador para recorrer posiciones
    {
        sendSPI(0x0+i,0x00);//recorre bit por bit colocando solo 0
    }
}   

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//FUNCIONES PIN PON

void analogo()//lee los voltajes generados por el joystick, los escala, e imprime dicho valor
  {
      mx=vrx.read();//lectura del volytaje en el eje x
      msx=mx;//multiplica por este 3300 con el fin escalar el valor leido
      my=vry.read();//lectura del voltaje en el eje y
      msy=my;//multiplica por este 3300 con el fin escalar el valor leido
      printf("movimiento_x = %f",msx);//imprimir en pantalla los valores leidos
      printf("movimiento_y = %f",msy);//imprimir en pantalla los valores leidos
  }
  
void barra()//desplaza la barra de lado a lado segun los movimientos en el joystick
{
    if(msx<0.2)//condicion segun la lectura del voltaje
       { 
        int temp1 = FIG_P[0]&(0x80);//se crea una variable temporal con el fin de alojar alli el resultado la operacion logica AND, con el fin de identificar si el bit mas significativo es 1 y asi limitar el dezplazamiento de la barra
        if(temp1==0)//condicion segun el resultado de la operacion
        {
            FIG_P[0]=FIG_P[0]<<1; //dezplazamiento hacia la izquierda en la matriz     
        }  
    }
    else if(msx>0.7)//condicion segun la lectura del voltaje
        {
        int temp1 = FIG_P[0]&(0x01);//se crea una variable temporal con el fin de alojar alli el resultado la operacion logica AND, con el fin de identificar si el bit menos significativo es 1 y asi limitar el dezplazamiento de la barra
        if(temp1==0)//condicion segun el resultado de la operacion
        {
            FIG_P[0]=FIG_P[0]>>1; //dezplazamiento hacia la derecha en la matriz
        }  
    }    
    
}

void barra_ini()//inicialmente se muestra la barra y la pelota, para que se dezplacen al tiempo antes de iniciar el juego 
{
    if(msx<0.3)//condicion segun la lectura del voltaje
        {
        int temp1 = FIG_P[0]&(0x80);//se crea una variable temporal con el fin de alojar alli el resultado la operacion logica AND, con el fin de identificar si el bit mas significativo es 1 y asi limitar el dezplazamiento de la barra
        if(temp1==0)//condicion segun el resultado de la operacion
        {
            FIG_P[0]=FIG_P[0]<<1;
            FIG_P[1]=FIG_P[1]<<1;//desplaza hacia la izquierda al tiempo de la barra y la pelota antes de comenzar el juego
             
        }  
    }
    else if(msx>0.7)//condicion segun la lectura del voltaje
        {
        int temp1 = FIG_P[0]&(0x01);//se crea una variable temporal con el fin de alojar alli el resultado la operacion logica AND, con el fin de identificar si el bit menos significativo es 1 y asi limitar el dezplazamiento de la barra
        if(temp1==0)//condicion segun el resultado de la operacion
        {
            FIG_P[0]=FIG_P[0]>>1;
            FIG_P[1]=FIG_P[1]>>1; //desplaza hacia la derecha al tiempo de la barra y la pelota antes de comenzar el juego
         
        }  
    }    
    
}

void move_fig()//mueve la palota por toda la matriz, y limita sus desplazamientos con cambios de direccion simulando un rebote contra paredes
{
    barra();//llamado a la funcion barra para poder dezplazar mientras la pelota se mueve
    if(dir==0) //condicional para el valor de la variable que controla el desplazamiento hacia los lados de la pelota
        {             
        if (up==0)//condicional para el valor de la variable que controla el desplazamiento hacia arriba y abajo de la pelota
        {       
        FIG_P[j+1] = FIG_P[j]>>1;//desplazamiento diagonal derecha ascendente de la pelota
        FIG_P[j] = 0x00;//elimina el paso de la pelota, de lo contrario dejaria los leds encendidos a medida que se desplaza
        } 
        else//condicional para el valor de la variable que controla el desplazamiento hacia arriba y abajo de la pelota
        {
        FIG_P[j+1] = FIG_P[j+2]>>1;//desplazamiento diagonal derecha descendente de la pelota
        FIG_P[j+2] = 0x00;//elimina el paso de la pelota, de lo contrario dejaria los leds encendidos a medida que se desplaza 
        } 
        
    }
    else //condicional para el valor de la variable que controla el desplazamiento hacia los lados de la pelota
        {   
        if(up==0)//condicional para el valor de la variable que controla el desplazamiento hacia arriba y abajo de la pelota
        { 
        FIG_P[j+1] = FIG_P[j]<<1;//desplazamiento diagonal izquierda ascendente de la pelota
        FIG_P[j] = 0x00;//elimina el paso de la pelota, de lo contrario dejaria los leds encendidos a medida que se desplaza
        }
        else//condicional para el valor de la variable que controla el desplazamiento hacia arriba y abajo de la pelota
        {
        FIG_P[j+1] = FIG_P[j+2]<<1;//desplazamiento diagonal izquierda descendente de la pelota
        FIG_P[j+2] = 0x00;//elimina el paso de la pelota, de lo contrario dejaria los leds encendidos a medida que se desplaza
        }
     
        
    }
    
    if(FIG_P[j+1]==0x80)//condiciona a que la pelota llegue al extremo izquierdo de la matriz, justo en el bit mas significativo 
    
    {   
        dir=0;// cambia de direccion hacia la derecha
    
    }
    else if(FIG_P[j+1]==0x01)//condiciona a que la pelota llegue al extremo derecho de la matriz, justo en el bit menos significativo
    {
        dir=1;// cambia de direccion hacia la izquierda
    }
    
    mostrar();//hace un llamado a la funcion mostrar con el fin de estar refrescando los datos a imprimir
    wait(a);// tiempo de espera para poder visualizar los dezplazamientos
    
    if(j+1==7)//condiciona a que la pelota llegue hasta la extremo superior de la matriz
    {
        up=1;//cambia la direccion de la pelota hacia abajo
    }
    else if(j==0)//condiciona a que la pelota llegue hasta la extremo inferior de la matriz
    {
        int temp2=FIG_P[j+1]&FIG_P[0];//se crea una variable temporal, para alojar alli el resultado de la operacion logica AND, con el fin de identificar si este aloja un 1 o un 0, de esta forma se sabe si la pelota alcanzo a ser golpeada por la barra
        if(temp2==0)//condiconal si la variable temproal es igual a 0
        {
             FIG_P[j] = 0x00;
             FIG_P[j+1] = 0x00;//al no ser devuelta la pelota por la barra, tanto como la pelota como la barra son borradas simulando un game over  
             mostrarg();//imprime en la matriz las letras G,O (iniciales de game over) indicando que el juego termino
             wait(3);//tiempo en el que duran las letras en pantalla
             borrar();//borra contenido actual en la matriz
             
        }
        up=0;// la pelota  al ser golpeada por la barra subira de nuevo 
        a=a/1.5;//reduce a la mitad el tiempo de espera, cada vez que la barra devuelve la pelota, aumenta la velocidad de dezplazamiento, es decir la velocidad del juego aumenta   
    }
}

void mostrar()//imprime en la matriz la barra y la pelota contenidas en el arreglo 
{
     for(int i=0; i<8; i++)//contador para recorrer posiciones
     {
         sendSPI(i+1, FIG_P[i]);//avanza de 1 en 1 para recorrer todas las posiciones del arreglo e irlas mostrando
     }
}

void mostrarg()//imprime en la matriz la barra y la pelota contenidas en el arreglo 
{
     for(int i=0; i<8; i++)//contador para recorrer posciones
     {
         sendSPI(i+1, FIG_U[i]);//avanza de 1 en 1 para recorrer todas las posiciones del arreglo e irlas mostrando
     }
}
void mostrarj()//imprime en la matriz la barra y la pelota contenidas en el arreglo 
{
     for(int i=0; i<6; i++)//contador para recorrer posciones
     {
         sendSPI(i+1, FIG_J[i]);//avanza de 1 en 1 para recorrer todas las posiciones del arreglo e irlas mostrando
     }
}

void inicio()//antes de comenzar el juego se hace una letura de voltaje en y del joystick, con el fin de lanzar la pelota e iniciar, ahora bien segun el desplazamiento que se haga de la barra con el joystick, la pelota tomara un direccion diferente de lanzamiento 
{
    analogo(); //se hace una llamada a la funcion analogo para hace las respectivas lecturas de voltaje 
    while(msy>0.7)//concional para el voltaje en y
    {
        analogo();//llamado a funcion analogo para leer voltajes
        barra_ini();//llamado a funcion barra_ini para que haga los desplazamientos laterales junto a la pelota
        mostrar();//llamado a funcion  mostrar imprime el arreglo que contiene la barra y la pelota
        if(msx<0.3)//condiciona segun voltaje en x
        {
            dir=1;//lanza la pelota inicialmente hacia la izquierda
        }
        else if (msx>0.7)//condiciona segun voltaje en x
        {
            dir=0;//lanza la pelota inicialmente hacia la derecha
        }
    }    
    
    
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//FUNCIONES MATRIZ


void imp_mat(uint8_t *temp)// Hace el desplazamiento hacia abajo de la figura 
{    
        sendSPI(cont-3,mat_act[cont-3]);
        sendSPI(cont-2,(*(temp+0) | mat_act[cont-2]));
        sendSPI(cont-1,(*(temp+1) | mat_act[cont-1]));
        sendSPI(cont,(*(temp+2) | mat_act[cont]));   
}
uint32_t read_command() //ingresa "<",">" y define el tamaño del vector "dat" 
{    
char intc=pc.getc();   
    while(intc != '<')
        intc=pc.getc();
    for (int i =0;i<MAXDAT;i++)
    dat[i]=pc.getc();
    intc=pc.getc();
    if(intc != '>'){
        return 0;
        }
    return 1;
}    
void cop_fi (uint8_t* tfig) //Almacena la figura en la matriz temporal 
{
    for(i=0;i<8;i++)
    {
    mat_tmp[i]=*(tfig+i)>>dat[1]-1;
    
    }
for(i=0;i<8;i++)
{
     mat_tmp1[i]= mat_tmp[i];
    }
}
void d_ale()
  {
      num=rand()%5+1;
      mcol=4;
      }
void ingred_d() //Tipo de figuras
{
uint8_t  tf=dat[0];
       
  switch(tf)
    {
      case tipo_c: // Cuadrado
      cop_fi(FIG_C);
      break;
      case tipo_s: //S
      cop_fi(FIG_S);
      break;
      case tipo_t: //T
      cop_fi(FIG_T);
      break;
      case tipo_i: //I
      cop_fi(FIG_I);
      break;
      case tipo_l: //L
      cop_fi(FIG_L);
      break;
     
    }
  }
  void analogoo()
  {
      mx=vrx.read();
      msx=mx;
      my=vry.read();
      msy=my;
      printf("Datosx = %f",msx);
  }
  void mover_fig()//mueve la figura por medio de botones 
{
    analogoo();
    int mfig;
   
    if(msy>0.7){
    mfig=1;}
    if(msx<0.3){//mover figura a la derecha
    mfig=2;}
    if(msx>0.7){//mover figura a la izquierda
    mfig=3;}
    
    switch(mfig)
    {
    case 1:
        grad++;
        if(grad<5){

        switch (grad)
        {
            case 1:
            mat_tmp[0]=mat_tmp1[4];
            mat_tmp[1]=mat_tmp1[5];
            mat_tmp[2]=mat_tmp1[6];
            break;
            case 2:
            mat_tmp[0]=mat_tmp1[0];
            mat_tmp[1]=mat_tmp1[2];
            mat_tmp[2]=mat_tmp1[1];
            break;
            case 3:
            mat_tmp[0]=mat_tmp1[6];
            mat_tmp[1]=mat_tmp1[5];
            mat_tmp[2]=mat_tmp1[4];
            break;
            case 4:
            mat_tmp[0]=mat_tmp1[0];
            mat_tmp[1]=mat_tmp1[1];
            mat_tmp[2]=mat_tmp1[2];
            break;
        }
        }
        if(grad>4){
            grad=0;
            }
        break;
    case 2:
        int temp1 = mat_tmp[i]&(0x01); 
        if(temp1==0){
            for(i=0;i<3;i++)
               mat_tmp[i]=mat_tmp[i]>>1; //mover derecha
            //for(i=0;i<7;i++)
              // mat_tmp1[i]=mat_tmp1[i]>>2;
           }
    break;
    case 3:
        int temp2 = mat_tmp[i]&(0x80); 
                if(temp2==0)
                {
       //for(i=0;i<7;i++){
            //mat_tmp1[i]=mat_tmp1[i]<<2;
         //   } 
        for(i=0;i<3;i++)
        {
           mat_tmp[i]=mat_tmp[i]<<1; //mover izquierda
        }
        }
        break;
}
}
void act_matrix(uint8_t*  temp)//Evalua figura guardada y su espacio
{ 
      for (i=0;i<9;i++){
        save=*(temp+2)& mat_act[i];
        if (save==0 )
        {
            fila=i+1;
        }
        if (save!=0)
        {
            fila=i;                                  
            i=9;
        }
        }
}
 
void guardar_mat(uint8_t *temp)//guarda la matriz
{
        mat_act[fila-3]=(*(temp+0))| mat_act[fila-3];
        mat_act[fila-2]=(*(temp+1))| mat_act[fila-2];
        mat_act[fila-1]=(*(temp+2))| mat_act[fila-1];
};
void elim_lin()
{
    for(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];
                }
            }
        }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//FUNCION PRINCIPAL

int main()
{
//orden de funciones
    test();
    borrar();
    mostrarj();
       
    while(1)//ciclo que determina segun lectura de la funcion analogo que caso del swtich tomar, es decir que juego elegir 
{    
        analogo();//se llama funcion para leer voltaje
        
        if(msx<0.3)//condicional que lleva al usuario al primer caso, en este caso juego de pin pon
            {
               op=1;//contiene las funciones del juego de pin pon
            }
         if(msx>0.7)//condicional que lleva al usuario al primer caso, en este caso juego de tetris
            {
                op=2;//contiene las funciones del juego de pin pon
            }
            
          switch(op)//switch que hace seleccion de juego
            {
            case 1: //contenido del juego de pin pon
            
                borrar();
                wait(0.2);
                inicio();
    
            while(1)//ciclo principal del juego
                {
                    mostrar();
                    analogo();
                    move_fig();
                    if(up==0)
                        {
                        j++; //la va sumando de a 1 a la variable puntero con el fin de que la pelota ascienda 
                        }
                     else
                        {
                        j--;//la va restando de a 1 a la variable puntero con el fin de que la pelota descienda 
                        }
            
                 }
                
                case 2://contenido del juego de tetris
                    borrar();
                    anal.attach(&mover_fig,500);
                    while(1)
                    {
                        while(read_command()==0);
                        ingred_d();   
                        act_matrix(mat_tmp); 
                        for (cont=0;cont<fila;cont++)
                        {     
                            analogoo();  
                            mover_fig();
                            act_matrix(mat_tmp);
                            imp_mat(mat_tmp);
                            wait_ms(500);
                        }
                    guardar_mat(mat_tmp);
                    elim_lin();
                    }
                }
       
}
}