[SOLUCIONADO] Sketch acelerometro

Tengo este codigo que encontre en internet y del que poco a poco consegui entender como funcionaba mi acelerometro… Lo que no entiendo es lo que hace el metodo readAccel, sobre todo las primeras lineas, luego entiendo que muestra por pantalla los datos de la aceleracion. Aqui les dejo el codigo por si me pueden echar una mano.
Gracias

#include <Wire.h>
 
#define DEVICE (0x53) // Device address as specified in data sheet
 
byte _buff[6];
 
char POWER_CTL = 0x2D;  //Power Control Register
char DATA_FORMAT = 0x31;
char DATAX0 = 0x32; //X-Axis Data 0
char DATAX1 = 0x33; //X-Axis Data 1
char DATAY0 = 0x34; //Y-Axis Data 0
char DATAY1 = 0x35; //Y-Axis Data 1
char DATAZ0 = 0x36; //Z-Axis Data 0
char DATAZ1 = 0x37; //Z-Axis Data 1
 
float xmax = 0, ymax = 0, zmax = 0;
long start = millis();
long iteraciones = 0;
 
void setup()
{
  Wire.begin(); // join i2c bus (address optional for master)
  Serial.begin(115200); // start serial for output. Make sure you set your Serial Monitor to the same!
  Serial.print("init");
   
  //Put the ADXL345 into +/- 4G range by writing the value 0x01 to the DATA_FORMAT register.
  writeTo(DATA_FORMAT, 0x01);
  //Put the ADXL345 into Measurement Mode by writing 0x08 to the POWER_CTL register.
  writeTo(POWER_CTL, 0x08);
}
 
void loop()
{
  readAccel(); // read the x/y/z tilt
  if(start+1000 > millis()){
    iteraciones++;
  }
   
  Serial.print(millis()/1000); // only read every 0,5 seconds
  delay(1000);
}
 
void readAccel() {
 
   
  uint8_t howManyBytesToRead = 6;
  readFrom( DATAX0, howManyBytesToRead, _buff); //read the acceleration data from the ADXL345
 
  // each axis reading comes in 10 bit resolution, ie 2 bytes. Least Significat Byte first!!
  // thus we are converting both bytes in to one int
  float x = (((int)_buff[1]) << 8) | _buff[0];
  if(x>xmax){xmax=x;}
  float y = (((int)_buff[3]) << 8) | _buff[2];
  if(y>ymax){ymax=y;} 
  float z = (((int)_buff[5]) << 8) | _buff[4];
  if(z>zmax){zmax=z;} 
  Serial.print("x: ");
  Serial.print( x/100 );
  Serial.print("G y: ");
  Serial.print( y/100 );
  Serial.print("G z: ");
  Serial.print( z/100 );
  Serial.print("G ");
  Serial.print("xmax: ");
  Serial.print( xmax/100 );
  Serial.print("G ymax: ");
  Serial.print( ymax/100 );
  Serial.print("G zmax: ");
  Serial.print( zmax/100 );
  Serial.println("G"); 
}
 
void writeTo(byte address, byte val) {
  Wire.beginTransmission(DEVICE); // start transmission to device
  Wire.write(address); // send register address
  Wire.write(val); // send value to write
  Wire.endTransmission(); // end transmission
}
 
// Reads num bytes starting from address register on device in to _buff array
void readFrom(byte address, int num, byte _buff[]) {
  Wire.beginTransmission(DEVICE); // start transmission to device
  Wire.write(address); // sends address to read from
  Wire.endTransmission(); // end transmission
 
  Wire.beginTransmission(DEVICE); // start transmission to device
  Wire.requestFrom(DEVICE, num); // request 6 bytes from device
 
  int i = 0;
  while(Wire.available()) // device may send less than requested (abnormal)
  {
    _buff[i] = Wire.read(); // receive a byte
    i++;
  }
  Wire.endTransmission(); // end transmission
}

es la direccion del aparato para poder comunicarse con el arduino y devolver los valores. devuelve para los tres ejes x/y/Z.

ahi puso varios data , pero solo usa DATAX0 , que segun ahi deberia devolver para el eje x0. pero devuelve para todos los ejes. (x/y/Z).

Gracias Naruto128 (buen manga por cierto :wink: ) pero eso lo entiendo, guarda la direccion de varios registros para modificar por ejemplo los valores maximos de la aceleracion y otras cosas. Lo que yo decia era esta parte del codigo:

void readAccel() {
 
   
  uint8_t howManyBytesToRead = 6;
  readFrom( DATAX0, howManyBytesToRead, _buff); //read the acceleration data from the ADXL345
 
  // each axis reading comes in 10 bit resolution, ie 2 bytes. Least Significat Byte first!!
  // thus we are converting both bytes in to one int
  float x = (((int)_buff[1]) << 8) | _buff[0];
  if(x>xmax){xmax=x;}
  float y = (((int)_buff[3]) << 8) | _buff[2];
  if(y>ymax){ymax=y;} 
  float z = (((int)_buff[5]) << 8) | _buff[4];
  if(z>zmax){zmax=z;} 
  Serial.print("x: ");
  Serial.print( x/100 );
  Serial.print("G y: ");
  Serial.print( y/100 );
  Serial.print("G z: ");
  Serial.print( z/100 );
  Serial.print("G ");
  Serial.print("xmax: ");
  Serial.print( xmax/100 );
  Serial.print("G ymax: ");
  Serial.print( ymax/100 );
  Serial.print("G zmax: ");
  Serial.print( zmax/100 );
  Serial.println("G"); 
}

Gracias por la ayuda. :slight_smile:

por eso, ase una peticion al la funcion readFrom( DATAX0, howManyBytesToRead, _buff); con la doreccion del aparato DATAX0, y este de devuelve un los datos de los tres ejes. pero este numero es algo asi 1234568, lo que hace mas a abajo es desconponer al numero supongamos que este numero ocupa 3 bytes, osea 1 byte para cada eje. . mirate esto como hacen el corrimiento de bits en la seccion Bitwise Operators http://arduino.cc/en/Reference/HomePage#.Ux3tm9j3Ct8

perdon , seria
hace una peticion a la funcion readFrom( DATAX0, howManyBytesToRead, _buff);
con una direcion del aparato DATAX0, y este devuelve los valores en un array =_buff.
mas abajo lo que hace es operar con 2 bytes, porque para un solo valor de un eje ., usa dos bytes.
lo que hace es operar, “suma” estos valores . (((int)_buff[1]) << 8) | _buff[0]

para los otros ejes hace lo mismo.
luego los muestra por puerto serial

Naruto128:
perdon , seria
hace una peticion a la funcion readFrom( DATAX0, howManyBytesToRead, _buff);
con una direcion del aparato DATAX0, y este devuelve los valores en un array =_buff.
mas abajo lo que hace es operar con 2 bytes, porque para un solo valor de un eje ., usa dos bytes.
lo que hace es operar, “suma” estos valores . (((int)_buff[1]) << 8) | _buff[0]

para los otros ejes hace lo mismo.
luego los muestra por puerto serial

Perdonado :wink: jejejejejeje
A ver si lo pillo… con esta instruccion:

  float z = (((int)_buff[5]) << 8) | _buff[4];

lo unico que hace es “sumar” los dos bytes leidos y los guarda en la misma variable no?
Seria como una concatenacion no?

EDITO: He mirado el playground y he visto el operando “<<”. Lo que hace es desplazar 8 bits a la izquierda el valor almacenado y luego hace la operacion booleana OR con el byte menos significativo del dato de aceleracion (el acelerometro da dos bytes por cada dato de la aceleracion). Asi consigue juntar los dos bytes de la aceleracion y guardarlos en una misma variable.

Quizas es muy tarde para preguntar, pero no entiendo como el programa accede a los ejes x2, y1, y2, z1, z2... en el ReadFrom solo entra con la direccion del primer byte de datos, alguien puede explicarme eso porfavor?