long ac[3]={0,0,0};

void setup ()
{
  Serial.begin (9600);
  analogReference (EXTERNAL);
}

void loop ()
{
  long media[3]={0,0,0};
  
  for (int j=0; j<1000; j++)
  {
    for (int i=0; i<3; i++)
    {
      analogRead (i);
      delay(30);
      ac[i] = analogRead (i);
      media[i] = ac[i] + media[i];
    }
  }
  
  for (int i=0; i<3; i++)
  {
    ac[i] = media[i] /1000;
  }  
  
  Serial.print ("   ");
  Serial.print (ac[0]);
  Serial.print ("      ");
  Serial.print (ac[1]);
  Serial.print ("      ");
  Serial.println (ac[2]);

  delay(500);
}

#include <math .h>
#include < LiquidCrystal.h>

LiquidCrystal lcd(12, 13, 11, 5, 4, 3, 2);

float sen[19]={0.0,0.09,0.17,0.26,0.34,0.42,\
0.5,0.57,0.64,0.70,0.77,0.82,0.87,0.91,0.94,\
0.96,0.98,0.99,1};  //Tabla de senos para evitar andar a calcular angulos

int ac[3]={0,0,0}, media[3]={535,542,531}, \
rango[3]={235,238,249};  //Tomamos unos valores medios de pruebas anteriores.

void setup ()
{
  Serial.begin(9600);                  //El serial para
                                       //pruebas propias.
  lcd.begin(20, 4);
  pinMode(6, OUTPUT);                  //Controla el contraste del lcd
  analogReference (EXTERNAL);          //Punto importante. Si vamos a usar
                                       //La patilla aref tenemos que poner
                                       //esta linea.
  
  analogWrite (6,32);
  
  lcd.setCursor(0,0);
  lcd.print ("Prueba acelerometro");
  lcd.setCursor(0,1);
  lcd.print ("  X      Y      Z");
}

void tenval ( int *eje, float *raz)  //Pasa el valor medido en la entrada
{                                    //analogica a un valor a partir del cual
  for (int i=0; i<3;i++)             //podemos calcular el angulo.
  {  
    eje[i] = eje[i] - media[i];
    raz[i]=(float)eje[i]/(float)rango[i];
  }
}

void senang (float *rel, int *ang)  //Podríamos calcular el arcsin(rel[i]
{                                   //pero al parecer hace perder muchos
  for (int i=0; i<3; i++)           //ciclos al microprocesador, entonces,
  {                                 //aprovechando que vamos a usar medidas
    for (int j=0; j<19; j++)        //de 5 en 5 grados, partimos de un array
    {                               //con los valores de los senos y comparamos.
      if ( abs(rel[i]) < sen[j] )   //Una simple multiplicacion con el indice
      {                             //del array nos da el angulo.
        if (rel[i] < 0)
          ang[i]=(1-j)*5;           //El angulo asi es negativo
        else
          ang[i]=(j-1)*5;
        if (ang[i] > 45)            //Esto es un apaño, para ajustar los valores
          ang[i]=ang[i]+5;          //a los que debieran.
        break;
      }
    }
  }
}

void imprime (int *rad)             //Saca los valores por la LCD
{
  lcd.setCursor(0,2);
  
  lcd.print ("  ");
  
  for (int i=0; i<3; i++)
  {
    lcd.setCursor (7*i+1,2);
    lcd.print (rad[i]);
    lcd.print ("  ");
  }
}

void loop ()
{
  float valor[3];
  int ang[3];
  
  for (int i=0; i<3; i++)           //Despues de leer en varios foros
  {                                 //esta es la forma mas correcta
    analogRead (i);                 //de leer por la entrada analógica
    delay (30);                     //evitando errores en lecturas
    ac[i]=analogRead (i);           //por influencia de otras entradas
  }                                 //analogicas
  
  /*Serial.print ("   ");
  Serial.print (ac[0]);
  Serial.print ("      ");
  Serial.print (ac[1]);
  Serial.print ("      ");
  Serial.println (ac[2]);*/
  
  tenval (ac,valor);
  
  tercersin(valor);
  
  senang (valor,ang);
  
  /*for (int i=0; i<3; i++)
  {
    Serial.print (valor[i]);
    Serial.print (" ");
  }
  Serial.println ("");*/
  
  imprime (ang);
}

//Despues de hacer un poco de "estudio" me decidí
//por descartar el Ã¡ngulo mayor, ya que esta medida
//era mas susceptible de error a la hora de leer de
//la entrada analogica. Tened en cuenta que el sin(70º)
//es 0'94, el sin(75º) es 0'96, el sin(80º) es 0'98 y
//el sin(85º) es 0'99, tenemos un rango de 20 grados
//donde los valores estan muy proximos.
//En vez de usar esta medida del acelerómetro, lo que hacemos
//es partir de que sin(ejex)^2 + sin(ejey)^2 + sin(ejez)^2 = 1
//y obtenemos un valor del sin del angulo mayor mas proximo
//a la realidad que usando la entrada analogica.
void tercersin ( float *sen)
{
  if ((sen[0] > sen[1]) && (sen[0] > sen[2]))
    sen[0]= sqrt(1 - (sen[1])*sen[1] - (sen[2])*sen[2]);
  else if ((sen[1] > sen[0]) && (sen[1] > sen[2]))
    sen[1]= sqrt(1 - (sen[0])*sen[0] - (sen[2])*sen[2]);
  else if ((sen[2] > sen[1]) && (sen[2] > sen[0]))
    sen[2]= sqrt(1 - (sen[1])*sen[1] - (sen[0])*sen[0]);
}

// Declaramos los puertos que corresponden a filas y
// columnas como una matriz
int aLed[2][4]={{2, 3, 4, 5}, {9, 8, 7, 6}};

// Declaramos los potenciometros que controlan los
// 2 ejes del joystick en el puerto analogico que
// corresponda. el formato del array es
//           {fila, columna}
int anPot[] = {1, 0};

// Creamos una variable para guardar la posición del
// led encendido
int iLedOn [] = {0, 0};

void setup (){

  Serial.begin (9600);

  for (int i=0; i < 4; i++){     // Por comodidad...
    pinMode (aLed [0] [i], OUTPUT);
    pinMode (aLed [1] [i], OUTPUT);
  }

  // Encendemos el primer led de la matriz
  digitalWrite (aLed [0] [0], HIGH);
  digitalWrite (aLed [1] [0], HIGH);
}

void OnLed (int *iLed){

  // Ahora sabemos que led está encendido...
  // ya no necesitamos el for, pero nos quedamos
  // con el para hacer mas cosas: 
  // apagamos la entrada, encendemos la nueva y 
  // la guardamos en la variable iLedOn

  for (int i=0; i < 2; i++){

    // este if es solo para no hacer nada, cuando 
    // no hay que hacer nada...
    if (iLed [i] < 4){

      // Apagamos la entrada vieja...
      digitalWrite (aLed [i] [iLedOn [i]], LOW);

      // Encendemos la nueva...
      digitalWrite (aLed [i] [iLed [i]], HIGH);

      // y guardamos.
      iLedOn [i] = iLed [i];
    }
  }
}

void loop (){

  int iVal[2];
  int iLed[2]= {0, 0};

  iVal [0] = analogRead (anPot [0]);
  iVal [1] = analogRead (anPot [1]);

  // Toca transformar los 10 bits a columnas y filas.
  for (int i=0; i < 2; i++){

    // Vamos a poner valores altos (100 y 900) para
    // no tener que preocuparnos por las diagonales

    // El joystick nos va a permitir movernos por la
    // matriz, así que solo nos va a interesar los
    // valores extremos arriba, abajo, derecha
    // e izquierda
    if (iVal [i] > 700){

      // Aumentamos la posicion, salvo que este
      // en el extremo (iLedOn[i]=3)
      // Si no pongo este else hace el bucle,
      // que no es lo que busco.
      if ( iLedOn [i] != 3)
        iLed [i] = iLedOn [i] + 1;
      else iLed [i] = 4;
    }
    else if (iVal [i] < 300){

      // Lo mismo pero ahora restamos y no hacemos
      // nada para iLedOn=0      
      if ( iLedOn [i] != 0)
        iLed [i] = iLedOn [i] - 1;
      else iLed [i] = 4;
    }
    else iLed [i] = 4;

    Serial.println (iLedOn [i]);
  }

  OnLed (iLed);

  // este delay es para poder manejar el joystic
  // sin problemas
  delay (175);
}

// Declaramos los puertos que corresponden a filas y
// columnas como una matriz
int aLed[2][3]={{2, 3, 4}, {7, 6, 5}};

// Declaramos los potenciometros que controlan los
// 2 ejes del joystick en el puerto analogico que
// corresponda. el formato del array es
//           {fila, columna}
int anPot[] = {1, 0};

void setup (){
  
  for (int i=0; i < 3; i++){     // Por comodidad...
    pinMode (aLed [0] [i], OUTPUT);
    pinMode (aLed [1] [i], OUTPUT);
  }
  
  // Encendemos el led central
  digitalWrite (aLed [0] [1], HIGH);
  digitalWrite (aLed [1] [1], HIGH);
}

void OnLed (int *iLed){
  
  // Apagamos todos los leds para encender el que
  // el que toca. Solo conseguimos no estar pendiente
  // del led que está encendido.
  for (int i=0; i<3; i++){

    digitalWrite (aLed [0] [i], LOW);
    digitalWrite (aLed [1] [i], LOW);
  }
 
  // Encendemos el que toca...
  digitalWrite (aLed [0][iLed[0]], HIGH);
  digitalWrite (aLed [1][iLed[1]], HIGH);
}
  
void loop (){
  
  int iVal[2];
  int iLed[2];
  
  iVal [0] = analogRead (anPot [0]);
  iVal [1] = analogRead (anPot [1]);
  
  // Toca transformar los 10 bits a columnas y filas.
  for (int i=0; i < 2; i++){

    // Los valores que están escritos funcionan más
    // o menos bien...

    // Podemos poner valores altos (100 y 900) para
    // no tener que preocuparnos por las diagonales
    
    // En caso de necesitar más precisión se puede
    // separar los valores de un potenciómetro con
    // los del otro... esto se consigue con un
    // if (i) {
    //   poteciómetro 1
    // }
    // else {
    //   potenciómetro 2
    // }
    
    if (iVal [i] > 700)
      iLed [i] = 2;
    else if (iVal [i] > 300)
      iLed [i] = 1;
    else iLed [i] = 0;
  }
  
  OnLed (iLed);
  
  delay (100);
}