proyecto: codigo pára motores controlados por acelerometro MMA7361L

buenos dias. estoy haciendo un proyecto escolar... un carrito de 2 motores dc y controlarlo con el acelerometro MMA7361L. queria saber si me pueden ayudar con codigo para que el carro vaya hacia adelante, derecha y izquierda. gracias :D

Pendulo invertido?

la verdad no se que me habla.. esque vi este video del codigo en arduino pero no se bien el codigo para copiarlo.

https://www.youtube.com/watch?v=eEhbOsMwuwg&list=UU1W2a3bo_XjYpM4o5xpd8xQ

Y porque no lo copias de youtube. Vas presionando pause y puedes copiarlo tranquilamente. O sino se lo pides al autor. varios lo han hecho luego si tienes problemas lo posteas y solucionamos el problema.

de hecho lo eh intentado pero en algunos segundos del video, le baja muy rapido y no se ve el codigo. y ya le eh pedido el codigo pero no me responde :( :D

Exactamente en que tiempo del video a ver si me pasa lo mismo.

No es ese código pero este otro tal vez te sirva

/* MMA7361 Accelerometer Test                                          BroHogan 12/10/10
 * CAUTION! input pins (Sleep, G-Select, Self-Test) are 3.3V max for HIGH 
 * Z should read 1g at rest. The 0g-Detect pin goes high when ALL THREE axes are at 0g.
 * X & Y Bandwidth: 400Hz (Z=300Hz) Output Impedance: 32K
 *   1.5g setting:  Sensitivity: 800 mV/g   -1g = 850mV    0g = 1650mV   1g = 2450mV
 *     6g setting:  Sensitivity: 206 mV/g   -1g = 1444mV   0g = 1650mV   1g = 1856mV
 * mV/analogRead unit = Aref V(3.3) / 1024.0
 * g = [mV/analogRead unit] * ([units] - ([Aref/2]) / [mvPerG]
 * deg. = asin (mVout - 1650mv) / 800mV)  (double asin (double x) ) in radians
 * 0-60 Time = 26.8224 / (g * 9.81) [60MPH = 26.8224 m/s, g = 9.81 m/s/s]
 * Added digitalSmooth by  Paul Badger 2007 - big improvement!
 * (see www.arduino.cc/playground/Main/DigitalSmooth)
 * SETUP: 
 * Best to use the 3.3V pin on the (Moderndevices) MMA7361 for ARef
 * TODO:
 * >1g && <-1g angle calc gets wonky (fixed).
 */

#define X_PIN       2                   // X Axis input (analog pin #) 
#define Y_PIN       1                   // Y Axis input (analog pin #) 
#define Z_PIN       3                   // Z Axis input (analog pin #) 
#define GSEL_PIN    14                  // pin on accel for range jmpr - LOW = 1.5 g range
#define ZERO_G_PIN  9                   // HIGH when X,Y,Z = 0 G
#define SLEEP_PIN   4                   // CAUTION 3.3V input pin - LOW to enable Sleep Mode

#define AREF_V      5000  //3280        // Aref voltage in mV BEST TO THE 3.2V ON THE ACCEL
#define LOW_RANGE   800                 // Sensitivity for 1.5 g range in mV/g
#define HIGH_RANGE  206                 // Sensitivity for 6 g range in mV/g
#define SAMPLES     13                  // SAMPLES should  be an odd number, no smaller than 3

int xSmoothArray [SAMPLES];             // array for holding X values for smoothing 
int ySmoothArray [SAMPLES];             // array for holding Y values for smoothing 
int zSmoothArray [SAMPLES];             // array for holding Z values for smoothing 
int xOffset, yOffset, zOffset;          // used to hold calculated offsets

int Acc_X, Acc_Y, Acc_Z;                // raw accel output
float Acc_Xg, Acc_Yg, Acc_Zg;           // accel output expressed in mg's
float Xdeg, Ydeg, Zdeg;                 // angle expressed in degrees
float mVperUnit;                        // calculated mV / analogRead unit
float mvPerG;                           // Sensitivity for current range in mV/g
float zeroTo60;                         // seconds for 0-60MPH acceleration equivalent
boolean lowRange = true;                // 1.5 g max if true - else 6g range 


void setup(){
  Serial.begin(9600);
  pinMode(ZERO_G_PIN,INPUT);            // HIGH when X,Y,Z = 0 G
  pinMode(GSEL_PIN,INPUT);              // LOW = 1.5 g range
  //analogReference(EXTERNAL);            // set if Aref pin wired to 3.3V source
  mVperUnit = AREF_V / 1024.0;          // calc mV / analogRead unit

  Serial.println("Lay flat for calibration!");
  CalAccel();                           // calc offsets
  delay (1000);
}


void loop(){
  //lowRange = !digitalRead(GSEL_PIN);    //  read pin on accel for range jmpr - If LOW set flag true
  lowRange = true;                      // USE THIS IF NOT READING JMPR ON ACCEL
  if (lowRange)mvPerG = LOW_RANGE;      // Set the mV/g based on the current range
  else mvPerG = HIGH_RANGE;

  Read_Accel();                         // read the X,Y,Z values from the MMA7361
  Disp_Vals();                          // display X,Y,Z g values
  delay(3000);
}

void Read_Accel(){
  //digitalSmooth(Acc_X,xSmoothArray,true); // reset running average
  for (int i=0; i< SAMPLES +2; i++){    // make a series of samples for smoothing
    Acc_X = analogRead(X_PIN) - xOffset;             // read the X Axis and apply offset
    Acc_X = digitalSmooth(Acc_X,xSmoothArray,false); // smooth X axis
    Acc_Y = analogRead(Y_PIN) - yOffset;             // read the Y Axis and apply offset
    Acc_Y = digitalSmooth(Acc_Y,ySmoothArray,false); // smooth Y axis
    Acc_Z = analogRead(Z_PIN) - zOffset;             // read the Z Axis and apply offset
    Acc_Z = digitalSmooth(Acc_Z,zSmoothArray,false); // smooth Z axis
    delay(5);                           // need this delay for 200Hz max sample rate
  }
  // now calc g's and angle . . .
  if (Acc_X >= 512) Acc_Xg = mVperUnit * (Acc_X - 512) / mvPerG;
  else Acc_Xg = ((512 - Acc_X) * (mVperUnit) / mvPerG) * -1;
  if (Acc_Xg >= -1.0 && Acc_Xg <= 1.0) Xdeg = asin(Acc_Xg) * (180.0/PI);
  else Xdeg = 0;
    zeroTo60 = 26.8224 / (Acc_Xg * 9.81);

  if (Acc_Y >= 512) Acc_Yg = mVperUnit * (Acc_Y - 512) / mvPerG;
  else Acc_Yg = ((512 - Acc_Y) * (mVperUnit) / mvPerG) * -1;
  if (Acc_Yg >= -1.0 && Acc_Yg <= 1.0) Ydeg = asin(Acc_Yg) * (180.0/PI);
  else Ydeg = 0;

  if (Acc_Z >= 512) Acc_Zg = mVperUnit * (Acc_Z - 512) / mvPerG;
  else Acc_Zg = ((512 - Acc_Z) * (mVperUnit) / mvPerG) * -1;
  Acc_Zg += 1.0;                        // add 1 g back into axis
  if (Acc_Zg >= -1.0 && Acc_Zg <= 1.0) Zdeg = asin(Acc_Zg) * (180.0/PI);
  else Zdeg = 0;
}

void Disp_Vals(){
  Serial.print("milli G's");
  Serial.print("\tX:");
  Serial.print(Acc_Xg * 1000,DEC);
  Serial.print("\tY:");
  Serial.print(Acc_Yg * 1000,DEC);
  Serial.print("\tZ:");
  Serial.println(Acc_Zg * 1000,DEC);

  Serial.print("Degrees  ");
  Serial.print("\tX:");
  Serial.print(Xdeg,DEC);
  Serial.print("\tY:");
  Serial.print(Ydeg,DEC);
  Serial.print("\tZ:");
  Serial.println(Zdeg,DEC);
  Serial.println("");

  if (zeroTo60 > 1 && zeroTo60 < 50){   // only use for zeroTo60 to eliminate noise
    // Serial.print("Sec 0-60: ");
    // Serial.println(zeroTo60,DEC); // zeroTo60 or Xdeg
  }
}



int digitalSmooth(int rawIn, int *sensSmoothArray, bool Reset){ 
  // modified from: www.arduino.cc/playground/Main/DigitalSmooth
  int j, k, temp, top, bottom;
  long total;
  static int i;
  static int sorted[SAMPLES];
  boolean done;

  if (Reset) {                    // added to reset running as an option
    for (j=0; j<SAMPLES; j++){
      sensSmoothArray[j] = 0;
      sorted[j] = 0;
    }
    i = 0;
    return 0;
  }

  i = (i + 1) % SAMPLES;    // increment counter and roll over if necc. -  % (modulo operator) rolls over variable
  sensSmoothArray[i] = rawIn;                 // input new data into the oldest slot

  for (j=0; j<SAMPLES; j++){     // transfer data array into anther array for sorting and averaging
    sorted[j] = sensSmoothArray[j];
  }

  done = 0;                // flag to know when we're done sorting              
  while(done != 1){        // simple swap sort, sorts numbers from lowest to highest
    done = 1;
    for (j = 0; j < (SAMPLES - 1); j++){
      if (sorted[j] > sorted[j + 1]){     // numbers are out of order - swap
        temp = sorted[j + 1];
        sorted [j+1] =  sorted[j] ;
        sorted [j] = temp;
        done = 0;
      }
    }
  }

  // throw out top and bottom 15% of samples - limit to throw out at least one from top and bottom
  bottom = max(((SAMPLES * 15)  / 100), 1); 
  top = min((((SAMPLES * 85) / 100) + 1  ), (SAMPLES - 1));   // the + 1 is to make up for asymmetry caused by integer rounding
  k = 0;
  total = 0;
  for ( j = bottom; j< top; j++){
    total += sorted[j];  // total remaining indices
    k++; 
  }
  return total / k;    // divide by number of samples
}

void CalAccel(){ // make 30 iterations, average, and save offset
  //otherwise you get an overflow. But 60 iterations should be fine
  xOffset=0;
  yOffset=0;
  zOffset=0;
  for (int i=1; i <= 30; i++){        
    xOffset += analogRead(X_PIN);    
    yOffset += analogRead(Y_PIN);
    zOffset += analogRead(Z_PIN);
    delay(5);                           // need delay for 200Hz sample rate
  }
  xOffset /=30;                         // get average
  xOffset -= 512;                       // 0g = 512 raw
  yOffset /=30;
  yOffset -= 512;
  zOffset /=30;                         // this also removes the 1g static accel
  zOffset -= 512;                       // added back later
}

y ese codigo hace lo mismo que el video? y ese codigo sirve para el MMA7361L? :D

no hace lo mismo, pero te sirve de guia. O estas completamente perdido?

Amigo, estas cosas no son fáciles de manejar, hay que sentarse y romperse un poco las neuronas.

Te aconsejo que empieces intentando entender como funciona todo para poder hacer algo de tu parte.

bueno, ok... pero una duda ese codigo que me diste en si en que consiste para los motores? nomas tengo esa duda? :-X

Ese código resuelve 75% de tu problema porque lee aceleraciones y ángulos y los pesenta
SI presenta ángulos puedes decidir como vas a mover el motor.
Entonces, ya sabes como se mueve el acelerómetro ahora falta que de tal rango a tal rango en x,y,z hagas esto o lo otro con los motores.
Con ver como vas a mover los motores, moverlos lo unico que falta es unir todo y tienes lo mismo.

Se entiende?