# Duvida Me Arm com acelerômetro MPU-6050 FIFO OVERFLOW

**URL:** <https://forum.fazedores.com/t/duvida-me-arm-com-acelerometro-mpu-6050-fifo-overflow/5741>\
**Category:** Arduino\
**Created:** [Setembro 8, 2018, 12:34am UTC](https://forum.fazedores.com/t/duvida-me-arm-com-acelerometro-mpu-6050-fifo-overflow/5741 "2018-09-08T00:34:51Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![iantandrade72](https://avatars.discourse-cdn.com/v4/letter/i/eada6e/32.png) [@iantandrade72](https://forum.fazedores.com/u/iantandrade72)\
**Post date:** [Setembro 8, 2018, 12:34am UTC](https://forum.fazedores.com/t/duvida-me-arm-com-acelerometro-mpu-6050-fifo-overflow/5741/1 "2018-09-08T00:34:51Z")

</div>

Ola Fazedores,

Estou fazendo um projeto de Conclusão de curso de engenharia elétrica e consiste em fazer um braço robotico programável utilizando um acelerômetro para coletar os dados.

O projeto terá somente um botao ao qual vai selecionar os modos : Operação, Programação e Run.

Modo Operação o braço irá apenas copiar os movimentos do acelerômetro que estará numa luva.

Modo Programação: O braço ira copiar os movimentos e irá guardar os dados .

Modo RUN : Irá repetir o programa gravado.

Estou fazendo o codigo de umas pesquisas que fiz, como nao entendo muito de programação me deparei com alguns problemas:

Parte do meu código é esse :

//Servo  
#include \<Servo.h\>  
#include “I2Cdev.h”  
#include “MPU6050\_6Axis\_MotionApps20.h”  
#if I2CDEV\_IMPLEMENTATION == I2CDEV\_ARDUINO\_WIRE  
#include “Wire.h”  
#endif  
// se AD0 estiver em low = 0x68  
// se AD0 estiver em high = 0x69  
MPU6050 mpu;  
//MPU6050 mpu(0x69); // \<-- tirar comentário caso AD0 = high  
#define OUTPUT\_READABLE\_YAWPITCHROLL  
#define LED\_PIN 13  
bool blinkState = false;  
// variáveis de controle/status do MPU  
bool dmpReady = false;  
uint8\_t mpuIntStatus;  
uint8\_t devStatus;  
uint16\_t packetSize;  
uint16\_t fifoCount;  
uint8\_t fifoBuffer[100];  
// Variáveis de orientação/movimento  
Quaternion q; // [w, x, y, z]  
VectorInt16 aa; // [x, y, z]  
VectorInt16 aaReal; // [x, y, z]  
VectorInt16 aaWorld; // [x, y, z]  
VectorFloat gravity; // [x, y, z]  
float euler[3]; // [psi, theta, phi]  
float ypr[3]; // [yaw, pitch, roll]  
uint8\_t teapotPacket[14] = { ‘$’, 0x02, 0,0, 0,0, 0,0, 0,0, 0x00, 0x00, ‘\r’, ‘\n’ };  
volatile bool mpuInterrupt = false;

////////////////////////////Defines novos //////////////////////////  
#define minGrip 15  
#define minBase 0  
#define minShou 60  
#define minElbw 60

#define maxGrip 45  
#define maxBase 170  
#define maxShou 180  
#define maxElbw 150

#define midGrip 30  
#define midBase 87  
#define midShou 138  
#define midElbw 100

int gripPosition[100];  
int basePosition[100];  
int shouPosition[100];  
int elbwPosition[100];

Servo myservoBase; // create servo object to control a servo yaw (Z)  
Servo myservoShou; // create servo object to control a servo Roll(Y)  
Servo myservoGrip; // create servo object to control a servo  
Servo myservoElbw; // create servo object to control a servo Pitch(X)

int servoBaseVal; // variables to read the value from the analog pin  
int servoShouVal;  
int servoGripVal;  
int servoElbwVal;

int servoBasePastVal; // variables to store the value from the analog pin at last loop  
int servoShouPastVal;  
int servoGripPastVal;  
int servoElbwPastVal;  
int recordPosition = 0; // if HIGH, record servo position  
int execTaskCmd = 0; // if HIGH, run program  
int tempo =20;

int numero = 0;  
boolean botaoAtu = false;  
boolean botaoAnt = false;  
float rec [15];  
int positionIndex = 0;  
const int botao = 3;

void dmpDataReady() {  
mpuInterrupt = true;  
}

void setup() {  
#if I2CDEV\_IMPLEMENTATION == I2CDEV\_ARDUINO\_WIRE  
Wire.begin();  
TWBR = 24; // clock de 400kHz no I2C (definir 200kHz para CPU de 8MHz)  
#elif I2CDEV\_IMPLEMENTATION == I2CDEV\_BUILTIN\_FASTWIRE  
Fastwire::setup(400, true);  
#endif  
//Define portas dos servos  
myservoShou.attach(9); // Eixo Y no pino 9  
myservoElbw.attach(10);// Eixo X no pino 10  
myservoBase.attach(11); // Eixo Z no pino 11  
pinMode(botao,INPUT);

Serial.begin(115200);  
Serial.println(F(“Inicializando dispositivos I2C…”));  
mpu.initialize();  
// verifica conexão  
Serial.println(F(“Testando conexão com os dispositivos…”));  
Serial.println(mpu.testConnection() ? F(“Conectado ao MPU6050 com sucesso”) : F(“Falha ao conectar ao MPU6050”));  
// carrega e configura o DMP  
Serial.println(F(“Inicializando DMP…”));  
devStatus = mpu.dmpInitialize();  
// definidos os valores de offset  
mpu.setXGyroOffset(220);  
mpu.setYGyroOffset(76);  
mpu.setZGyroOffset(85);  
mpu.setZAccelOffset(1788);  
// garante que etapa anterior tenha terminado  
if (devStatus == 0) {  
// liga o DMP  
Serial.println(F(“Habilitando DMP…”));  
mpu.setDMPEnabled(true);  
// Habilita detecção de interrupções  
Serial.println(F(“Habilitando detecção de interrupção (Arduino external interrupt 0)…”));  
attachInterrupt(0, dmpDataReady, RISING);  
mpuIntStatus = mpu.getIntStatus();  
// marca DMP como pronto para uso  
Serial.println(F(“DMP pronto! Aguardando primeira interrupção…”));  
dmpReady = true;  
// pega tamanho de pacote esperado  
packetSize = mpu.dmpGetFIFOPacketSize();  
} else {  
// ERRORS!  
// 1 = erro ao carregar memoria inicial  
// 2 = Configuração do DMP falhou  
Serial.print(F(“Inicialização do DMP falhou (código “));  
Serial.print(devStatus);  
Serial.println(F(”)”));  
}  
// configura saída do LED  
pinMode(LED\_PIN, OUTPUT);  
}

void loop() {  
// Em caso de falha encerra o programa  
if (!dmpReady) return;  
// aguarda por MPU interrupt ou pacote extra disponivel  
while (!mpuInterrupt && fifoCount \< packetSize) {  
// Espaço para programa caso Interrupt = true  
}  
// reseta marcador de interrupt and lê o byte INT\_STATUS  
mpuInterrupt = false;  
mpuIntStatus = mpu.getIntStatus();  
// lê a contagem de FIFO atual  
fifoCount = mpu.getFIFOCount();  
// checa se há overflow  
if ((mpuIntStatus & 0x10) || fifoCount == 1024) {  
// reinicia o FIFO  
mpu.resetFIFO();  
Serial.println(F(“FIFO overflow!”));  
// checa se DMP está disponível  
} else if (mpuIntStatus & 0x02) {  
// aguarda entrada correta dos dados  
while (fifoCount \< packetSize) fifoCount = mpu.getFIFOCount();  
// le um pacote do FIFO  
mpu.getFIFOBytes(fifoBuffer, packetSize);  
fifoCount -= packetSize;  
#ifdef OUTPUT\_READABLE\_YAWPITCHROLL  
// mostra angulos de Euler em graus  
mpu.dmpGetQuaternion(&q, fifoBuffer);  
mpu.dmpGetGravity(&gravity, &q);  
mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);

botaoAtu = digitalRead(botao);  
if (botaoAtu && !botaoAnt) {  
numero++;

}  
switch (numero){  
case 0:  
Serial.print(“ypr\t”);  
Serial.print(ypr[0] \* 180/M\_PI);  
myservoBase.write(int(ypr[0] \* -180/M\_PI)+90); //Rotação eixo Z

```
      Serial.print("\t");
      Serial.print(ypr[1] * 180/M_PI);
      myservoShou.write(int(ypr[1] * -180/M_PI)+90); // Rotação eixo Y

      Serial.print("\t");
      Serial.println(ypr[2] * 180/M_PI);
      myservoElbw.write(int(ypr[2] * -180/M_PI)+90); // Rotação eixo X
  break;

 case 1:
      Serial.print("GRAVANDO CODIGO");
           recArmPosition();
              break;

 case 2: 
      Serial.print("Executar Programa");
                Serial.println("programa gravado");
                 for (int i=0; i <positionIndex;i++)
            {
 
              Serial.println(basePosition[i]);
              Serial.println(shouPosition[i]);
              Serial.println( elbwPosition[i]);

                break;

```

}}}

```
void recArmPosition(){
  tempo = tempo++;
  servoBaseVal = ypr[0] * 180/M_PI;
  servoShouVal= ypr[1] * 180/M_PI;
  servoElbwVal =ypr[2] * 180/M_PI;

```

switch (tempo){  
case 0:  
positionIndex++;  
gripPosition[positionIndex] = servoGripVal;  
basePosition[positionIndex] = servoBaseVal;  
shouPosition[positionIndex] = servoShouVal;  
elbwPosition[positionIndex] = servoElbwVal;

```
            delay(2000);
            tempo=tempo +1;
            break;
            
     case 1:
             positionIndex++;     
            gripPosition[positionIndex] = servoGripVal;              
            basePosition[positionIndex] = servoBaseVal;
            shouPosition[positionIndex] = servoShouVal;      
            elbwPosition[positionIndex] = servoElbwVal;
            
            delay(2000);
            tempo=tempo +1;
            break;
     case 2: 
             positionIndex++;     
            gripPosition[positionIndex] = servoGripVal;              
            basePosition[positionIndex] = servoBaseVal;
            shouPosition[positionIndex] = servoShouVal;      
            elbwPosition[positionIndex] = servoElbwVal;
            
            delay(2000);
            tempo=tempo +1;
            break;
     case 3:
            positionIndex++;     
            gripPosition[positionIndex] = servoGripVal;              
            basePosition[positionIndex] = servoBaseVal;
            shouPosition[positionIndex] = servoShouVal;      
            elbwPosition[positionIndex] = servoElbwVal;
            
            delay(2000);
            tempo=tempo +1;
            break;
     case 4: 
           positionIndex++;     
            gripPosition[positionIndex] = servoGripVal;              
            basePosition[positionIndex] = servoBaseVal;
            shouPosition[positionIndex] = servoShouVal;      
            elbwPosition[positionIndex] = servoElbwVal;
            
            delay(2000);
            tempo=tempo +1;
            break;
     case 5:
          positionIndex++;     
            gripPosition[positionIndex] = servoGripVal;              
            basePosition[positionIndex] = servoBaseVal;
            shouPosition[positionIndex] = servoShouVal;      
            elbwPosition[positionIndex] = servoElbwVal;
            
            delay(2000);
            tempo=tempo +1;
            break;

     case 6: 
            positionIndex++;     
            gripPosition[positionIndex] = servoGripVal;              
            basePosition[positionIndex] = servoBaseVal;
            shouPosition[positionIndex] = servoShouVal;      
            elbwPosition[positionIndex] = servoElbwVal;
            
            delay(2000);
            tempo=tempo +1;
            break;
     case 7:
            positionIndex++;     
            gripPosition[positionIndex] = servoGripVal;              
            basePosition[positionIndex] = servoBaseVal;
            shouPosition[positionIndex] = servoShouVal;      
            elbwPosition[positionIndex] = servoElbwVal;
            
            delay(2000);
            tempo= 0;
            break;  

```

}  
}

Esse é uma parte do meu código ao qual estou tentando gravar as informações do MPU nos arrays Sholder, Elbow e Base para depois reproduzir, mas esta dando erro de FIFO OVERFLOW no serial. Gostaria de ver os dados gravados no serial para saber se esta gravando mesmo. Se alguém puder me ajudar a passar desse problema eu agradeço desde já .