FIFO Overflow

[lecristoph]

Hi!

I'm trying to communicate with the MPU6050 in MATLAB, where if I send a request 'A' via serial bluetooth to the Arduino UNO, I get the current reading of the euler angle. This kind of works for me at the moment, but if I request the serial print out of the angle too many times in a row, or to frequently, I get some kind of FIFO overflow, so that I have to reset the arduino and re-initialize the Bluetooth connection before I can use it again. It usually takes less than 5-10 requests before the MPU hangs and does not respond anymore. I'll post my arduino code below. I reqest the angle by sending the character 'A' via bluetooth to the arduino. In the same way, I use a motor shield so that I can control two DC-motors that are connected to the arduino as well, by sending various commands via bluetooth.

 

#include <SoftwareSerial.h>
SoftwareSerial BT(5, 6); 
// creates a "virtual" serial port/UART
// connect BT module TX to D5
// connect BT module RX to D6
// connect BT Vcc to 3.3V, GND to GND

#include "I2Cdev.h"
#include "MPU6050_6Axis_MotionApps20.h"
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
    #include "Wire.h"
#endif
MPU6050 mpu;
#define OUTPUT_READABLE_EULER
#define LED_PIN 13 //

char val = 0;
int speed = 40;
int a =0;
bool blinkState = false;

// MPU control/status vars
bool dmpReady = false;  // set true if DMP init was successful
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer
int angle;

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorInt16 aa;         // [x, y, z]            accel sensor measurements
VectorInt16 aaReal;     // [x, y, z]            gravity-free accel sensor measurements
VectorInt16 aaWorld;    // [x, y, z]            world-frame accel sensor measurements
VectorFloat gravity;    // [x, y, z]            gravity vector
float euler[3];         // [psi, theta, phi]    Euler angle container
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector


// ================================================================
// ===               INTERRUPT DETECTION ROUTINE                ===
// ================================================================

volatile bool mpuInterrupt = false;     // indicates whether MPU interrupt pin has gone high
void dmpDataReady() {
    mpuInterrupt = true;
}

// ================================================================
// ===                      INITIAL SETUP                       ===
// ================================================================

void setup() {
  


    //Setup Channel A
  pinMode(12, OUTPUT); //Initiates Motor Channel A pin
  pinMode(9, OUTPUT); //Initiates Brake Channel A pin
  


  
    // join I2C bus (I2Cdev library doesn't do this automatically)
    #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
        Wire.begin();
        TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz)
    #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
        Fastwire::setup(400, true);
    #endif

    // initialize serial communication
   // Serial.begin(9600);
   BT.begin(9600);
    while (!Serial); // wait for Leonardo enumeration, others continue immediately

   mpu.initialize();

   
   devStatus = mpu.dmpInitialize();

    // supply your own gyro offsets here, scaled for min sensitivity
    mpu.setXGyroOffset(38);
    mpu.setYGyroOffset(-91);
    mpu.setZGyroOffset(46);
    mpu.setZAccelOffset(1682); // 1688 factory default for my test chip

    // make sure it worked (returns 0 if so)
    if (devStatus == 0) {

        mpu.setDMPEnabled(true);

       
        attachInterrupt(0, dmpDataReady, RISING);
        
        mpuIntStatus = mpu.getIntStatus();

        // set our DMP Ready flag so the main loop() function knows it's okay to use it
        Serial.println(F("DMP ready! Waiting for first interrupt..."));
        dmpReady = true;

        // get expected DMP packet size for later comparison
        packetSize = mpu.dmpGetFIFOPacketSize();
    } else {
        // ERROR!
        // 1 = initial memory load failed
        // 2 = DMP configuration updates failed
        // (if it's going to break, usually the code will be 1)
        Serial.print(F("DMP Initialization failed (code "));
        Serial.print(devStatus);
        Serial.println(F(")"));
    }


    // configure LED for output
    pinMode(LED_PIN, OUTPUT);
}

// ================================================================
// ===                    MAIN PROGRAM LOOP                     ===
// ================================================================

void loop() {


   // MPU run
  
    // if programming failed, don't try to do anything
    if (!dmpReady) return;

    // wait for MPU interrupt or extra packet(s) available
    while (!mpuInterrupt && fifoCount < packetSize) 
    {

if (BT.available() )
  {
   val = BT.read();
   if (val == 'F')
   {
//forward @ speed 40
  digitalWrite(12, HIGH); //Establishes forward direction of Channel A
    digitalWrite(13, LOW); //Establishes forward direction of Channel B
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  digitalWrite(8, LOW);   //Disengage the Brake for Channel B
  analogWrite(3, speed);   //Spins the motor on Channel A at speed 50. (full speed = 255) (variable speed defined at 50 as standard)
  analogWrite(11, speed); //Spins motor Channel B at speed 20.
   }
   else if(val == 'G')
   {
//Backwards @ speed 40
  digitalWrite(12, LOW); //Establishes Backwards direction of Channel A
    digitalWrite(13, HIGH); //Establishes Backwards direction of Channel B
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  digitalWrite(8, LOW);   //Disengage the Brake for Channel B
  analogWrite(3, speed);   //Spins the motor on Channel A at speed 40. (full speed = 255) (variable speed defined at 50 as standard)
  analogWrite(11, speed); //Spins motor Channel B at speed 40
   }
 else if (val == 'B'){
  //Breaks both Channels
  digitalWrite(9, HIGH); //Eengage the Brake for Channel A
  digitalWrite(8, HIGH); //Eengage the Brake for Channel B
 }
 else if (val == 'L'){
//Turn left @ speed 20
  digitalWrite(12, HIGH); //Establishes forward direction of Channel A
  digitalWrite(9, LOW);   //Disengage the Brake for Channel A
  digitalWrite(8, HIGH);   //Engage the Brake for Channel B
  analogWrite(3, speed);   //Spins the motor on Channel A at speed 40. (full speed = 255) 
  }       
 else if (val == 'R'){
//Turn left @ speed 20
  digitalWrite(13, LOW); //Establishes forward direction of Channel B
  digitalWrite(8, LOW);   //Disengage the Brake for Channel B
  digitalWrite(9, HIGH);   //Engage the Brake for Channel A
  analogWrite(11, speed);   //Spins the motor on Channel A at speed 40. (full speed = 255) 
  }


 else if (val == 'A')
   {

// display Euler angles in degrees
            mpu.dmpGetQuaternion(&q, fifoBuffer);
            mpu.dmpGetEuler(euler, &q);
//            Serial.print("\n");
            BT.println(euler[0] * 180/M_PI);

//            Serial.print(euler[1] * 180/M_PI);
//            Serial.print("\t");
//            Serial.println(euler[2] * 180/M_PI);


        // blink LED to indicate activity
        blinkState = !blinkState;
        digitalWrite(LED_PIN, blinkState);   
   }  
  }
 }

    // reset interrupt flag and get INT_STATUS byte
    mpuInterrupt = false;
    mpuIntStatus = mpu.getIntStatus();

    // get current FIFO count
    fifoCount = mpu.getFIFOCount();

    // check for overflow (this should never happen unless our code is too inefficient)
    if ((mpuIntStatus & 0x10) || fifoCount == 1024) {
        // reset so we can continue cleanly
        mpu.resetFIFO();
        Serial.println(F("FIFO overflow!"));

    // otherwise, check for DMP data ready interrupt (this should happen frequently)
    } else if (mpuIntStatus & 0x02) {
        // wait for correct available data length, should be a VERY short wait
        while (fifoCount < packetSize) fifoCount = mpu.getFIFOCount();

        // read a packet from FIFO
        mpu.getFIFOBytes(fifoBuffer, packetSize);
       
        // track FIFO count here in case there is > 1 packet available
        // (this lets us immediately read more without waiting for an interrupt)
        fifoCount -= packetSize;
                
    }
    
}