File content as of revision 5:f8ca9f670abe:

// Read from I2C slave at address 0x62

#include "mbed.h"
#include "Ticker.h"
#include "MPU6050.h"

Serial command(USBTX,USBRX);        //habilitar la comunicacion serial a traves del puerto usb.
MPU6050 Wire(PB_9 , PB_8 ); 

SPI deviceM(PB_15, PB_14, PB_13);
DigitalOut ssel (PB_12);
//SPI deviceM(PB_5, PB_4, PB_3);    //define el Clock, Dato salida (miso) y Dato de entrada (mosi).
//DigitalOut ssel (PB_9);           //Chip Select para el controlador.
//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;
DigitalIn pulsador(PH_1);
AnalogIn in1(PC_2);
AnalogIn in2(PC_3);

#define  VEL 200                     //Velocidad de actualizacion de dato en el controlador.
#define  MIN 1
#define  MAX 8
#define  MINC 128
#define  MAXC 1
#define  DEL 0.1
#define  GIRO 2
#define  G_DIAG 2

int columna=1,manzanas=0;
int fila=1, fil=1, colum=1;
bool _boton=0;
void blink();
void boton();

//--------------------------------------------------
//-------------------TICKER------------------------
//--------------------------------------------------  
void attime() 
{
    blink();
    boton();
}; 

//--------------------------------------------------
//-------------------BOTON------------------------
//--------------------------------------------------  
void boton()
{
    if (pulsador == 0) 
        {
            command.printf("Button pressed %b\n", _boton);
            _boton=!_boton;
        }
}  

//--------------------------------------------------
//-------------------SPI------------------------
//--------------------------------------------------   
void sendSPI(uint8_t d1, uint8_t d2)
{
    deviceM.unlock();
    ssel=0;
    deviceM.write(d1); 
    deviceM.write(d2);
    ssel=1;
    deviceM.lock();
};


//--------------------------------------------------
//-------------------TEST------------------------
//--------------------------------------------------   
void test()                 //test
{
    sendSPI(0x09,0);        //no decodificacion
    sendSPI(0x0A,0x9);     //intensidad
    sendSPI(0x0B,0x07);     //usa 7 leds                     
    sendSPI(0x0C,1);        //no apaga
    sendSPI(0x0F,0);        //operacion normal     
}


//--------------------------------------------------
//-------------------BORRAR------------------------
//--------------------------------------------------   
void borrar()            //borrar toda la matriz;
{
    int i;
    for(i=0;i<=8;i++)
    {
        sendSPI(i,0);
    }
}


//--------------------------------------------------
//-------------------GENERAR_PUNTO------------------------
//--------------------------------------------------   
void generar_punto()
{
    int col[8]={1,2,4,8,16,32,64,128};
    //int fil=0;
    borrar();
    int _fil=fil;
    fil= rand() % 7+1;
    int y= rand() % 7+1;
    command.printf("\n\n Fila: %d",fil); 
    command.printf("\n Columna:%d",col[y]);
    //int time=0;
    //while(time<4)
    //    {
    if(_fil==fil)
    colum=colum+col[y];
    colum=col[y];
    if(fil==fila){
                    int guarda_linea=columna+colum;
                    sendSPI(fila,guarda_linea);
                    }
    else
    sendSPI(fil,col[y]);
    
    //    wait_ms(VEL);
    //    sendSPI(fil,0);
    //    wait_ms(VEL);
    //    time++;
    //    }
    
}

//--------------------------------------------------
//-------------------BLINK------------------------
//--------------------------------------------------  
void blink(){
    sendSPI(fil,0);
        if(fil==fila)
                sendSPI(fila,columna);
                wait(0.05);
    }

//--------------------------------------------------
//-------------------REVISAR_MOV------------------------
//--------------------------------------------------   
void revisar_mov(uint8_t correr){
    switch (correr){
        
        case 2:
        columna=columna<<1;
        fila--;
        if (columna>MINC)
            columna=MAXC;
        if (fila<MIN){
            fila=MAX;
            sendSPI(MIN,0);
            }
        sendSPI(fila+1,0);
        break;
        
        case 4:
        columna=columna<<1;
        fila++;
        if (fila>MAX){
            fila=MIN;
            sendSPI(MAX,0);
            }
        if (columna>MINC)
            columna=MAXC;
        sendSPI(fila-1,0);
        break;
        
        case 1:
        columna=columna>>1;
        fila--;
        if (columna<MAXC)
            columna=MINC;
        if (fila<MIN){
            fila=MAX;
            sendSPI(MIN,0);
            }
        sendSPI(fila+1,0);
        //command.printf("\n case1 Col:%d",columna);
        //command.printf("\n FIL:%d",fila);
        break;
        
        case 3:
        columna=columna>>1;
        fila++;
        if (columna<MAXC)
            columna=MINC;
        if (fila>MAX){
            fila=MIN;
            sendSPI(MAX,0);
            }
        sendSPI(fila-1,0);
        //command.printf("\n case3 Col:%d",columna);
        //command.printf("\n FIL:%d",fila);
        break;
        
        case 28:
        columna=columna<<1;
        if (columna>MINC)
            columna=MAXC;
        break;
        
        case 29:
        columna=columna>>1;
        if (columna<MAXC)
            columna=MINC;
        break;
        
        case 30:
        fila--;
        if (fila<MIN){
            fila=MAX;
            sendSPI(MIN,0);
            }
        sendSPI(fila+1,0);
        break;
        
        case 31:
        fila++;
        if (fila>MAX){
            fila=MIN;
            sendSPI(MAX,0);
            }
        sendSPI(fila-1,0);
        break;  
        
        case 0:
        break; 
        }
    }
    
//--------------------------------------------------
//-------------------VELOCIDAD-----------------------
//-------------------------------------------------- 
int velocidad(float _acc[3])
{
    int vel,x=1,y=2; //
    int acc[3];
        acc[0]=(int)_acc[0];
        acc[1]=(int)_acc[1];
       if((acc[0]>GIRO) || (acc[0]<-GIRO) || (acc[1]>GIRO) || (acc[1]<-GIRO))
        {
                if((acc[0]>(GIRO+x)) || (acc[0]<-(GIRO+x)) || (acc[1]>(GIRO+x)) || (acc[1]<-(GIRO+x)))
                    {
                        vel=300; 
                        if((acc[0]>(GIRO+y)) || (acc[0]<-(GIRO+y)) || (acc[1]>(GIRO+y)) || (acc[1]<-(GIRO+y)))
                            vel=100;
                    }
                else
                    vel=500;   
        }
    return vel;
}
    
//--------------------------------------------------
//-------------------BUSCADOR------------------------
//--------------------------------------------------   
void buscador()
{
    uint8_t correr;
    int y=0,x=0,acc[3],v;
    //float gyro[3]; Wire.getGyro(gyro);
    float _acc[3];     
    //command.printf("Accelerometer: \t X= %f, \t Y= %f, \t Z=%f \n", acc[0],acc[1],acc[2]);
    //command.printf("Gyroscope: \t X= %f, \t Y= %f, \t Z=%f \n", gyro[0],gyro[1],gyro[2]);
       if(_boton==1) 
        {
            x=((int)(in1.read()*-650))+13;
            y=((int)(in2.read()*-650))+13;
            acc[0]=x;
            acc[1]=y;
            command.printf("Joystick: \t X= %d, \t Y= %d, \n", x,y); 
        }
        else
        {
            Wire.getAccelero(_acc);
            acc[0]=(int)_acc[0];
            acc[1]=(int)_acc[1];
            command.printf("Accelerometer: \t X= %d, \t Y= %d, \n", acc[0],acc[1]);     
        }
        
        command.printf("Velocidad %d \n", v);
        if(acc[0]>GIRO)         //eje x derecha
        {
            if(acc[1]>G_DIAG)     //eje y arriba
            correr=1;
            else if(acc[1]<-G_DIAG)//eje y abajo
            correr=2;
            else
            correr=30;
            }          
    else if(acc[0]<-GIRO)   //eje x izquierda
        {
            if(acc[1]>G_DIAG)     //eje y arriba
                    correr=3;
                    else if(acc[1]<-G_DIAG)//eje y abajo
                    correr=4;
                    else
                    correr=31;
                    }           
    else if(acc[1]>GIRO)    //eje y arriba
                    correr=29;
    else if(acc[1]<-GIRO)   //eje y abajo
                    correr=28;
                else
                correr=0; //
        revisar_mov(correr);        
        v=velocidad(_acc);
        wait_ms(v);
        //wait (DEL);
    //command.printf("\n correr:\n %d",correr);    
}


//--------------------------------------------------
//-------------------COMER------------------------
//--------------------------------------------------   
int comer ()
{
            int x=0;
            if((fil==fila)&&((colum & columna) != 0))
            {
            manzanas++;
            sendSPI(fila,columna);
                        for(int i=0;i<manzanas;i++)
                        {
                            int guarda_linea=columna+colum;
                            sendSPI(fila,guarda_linea);
                            generar_punto();
                            sendSPI(fil,colum);
                            //com_tar.putc(x);
                        }
                        x=1;
            }
                return x;
}


//--------------------------------------------------
//-------------------VALIDAR_CONTRINCANTE------------------------
//--------------------------------------------------   
int validar_contrincante(){
    int x=com_tar.getc();
    return x;
    }


//--------------------------------------------------
//-------------------MAIN------------------------
//--------------------------------------------------   
int main ()
{
    int guarda_linea,x=0;
    timer.attach(&attime, 0.1);
    test();
    borrar();
    sendSPI(fila,columna);
    generar_punto();
    while(1)
        {
        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
                    {
                        guarda_linea=columna;
                        sendSPI(fila,guarda_linea);
                        sendSPI(fil,colum);  
                    }
                }
            else{
                sendSPI(fila,columna);
                }
        //generar_punto();
        }
}