Problemm with the MPU6050 library
Well I don't know exactly why this work, but base on this question this. To solve this I should add 'inline' keyword in every method definition on the MPU6050_6Axis_MotionApps20.h
Like this:
inline uint8_t MPU6050::dmpInitialize() {
    // reset device
    DEBUG_PRINTLN(F(&quot;\n\nResetting MPU6050...&quot;));
    reset();
    delay(30); // wait after reset

    // disable sleep mode
    setSleepEnabled(false);

    // get MPU hardware revision
    setMemoryBank(0x10, true, true);
    setMemoryStartAddress(0x06);
    Serial.println(F(&quot;Checking hardware revision...&quot;));
    Serial.print(F(&quot;Revision @ user[16][6] = &quot;));
    Serial.println(readMemoryByte(), HEX);
    Serial.println(F(&quot;Resetting memory bank selection to 0...&quot;));
    setMemoryBank(0, false, false);

    // check OTP bank valid
    DEBUG_PRINTLN(F(&quot;Reading OTP bank valid flag...&quot;));
    DEBUG_PRINT(F(&quot;OTP bank is &quot;));
    DEBUG_PRINTLN(getOTPBankValid() ? F(&quot;valid!&quot;) : F(&quot;invalid!&quot;));

    // setup weird slave stuff (?)
    DEBUG_PRINTLN(F(&quot;Setting slave 0 address to 0x7F...&quot;));
    setSlaveAddress(0, 0x7F);
    DEBUG_PRINTLN(F(&quot;Disabling I2C Master mode...&quot;));
    setI2CMasterModeEnabled(false);
    DEBUG_PRINTLN(F(&quot;Setting slave 0 address to 0x68 (self)...&quot;));
    setSlaveAddress(0, 0x68);
    DEBUG_PRINTLN(F(&quot;Resetting I2C Master control...&quot;));
    resetI2CMaster();
    delay(20);
    DEBUG_PRINTLN(F(&quot;Setting clock source to Z Gyro...&quot;));
    setClockSource(MPU6050_CLOCK_PLL_ZGYRO);

    DEBUG_PRINTLN(F(&quot;Setting DMP and FIFO_OFLOW interrupts enabled...&quot;));
    setIntEnabled(1&lt;&lt;MPU6050_INTERRUPT_FIFO_OFLOW_BIT|1&lt;&lt;MPU6050_INTERRUPT_DMP_INT_BIT);

    DEBUG_PRINTLN(F(&quot;Setting sample rate to 200Hz...&quot;));
    setRate(4); // 1khz / (1 + 4) = 200 Hz

    DEBUG_PRINTLN(F(&quot;Setting external frame sync to TEMP_OUT_L[0]...&quot;));
    setExternalFrameSync(MPU6050_EXT_SYNC_TEMP_OUT_L);

    DEBUG_PRINTLN(F(&quot;Setting DLPF bandwidth to 42Hz...&quot;));
    setDLPFMode(MPU6050_DLPF_BW_42);

    DEBUG_PRINTLN(F(&quot;Setting gyro sensitivity to +/- 2000 deg/sec...&quot;));
    setFullScaleGyroRange(MPU6050_GYRO_FS_2000);

    // load DMP code into memory banks
    DEBUG_PRINT(F(&quot;Writing DMP code to MPU memory banks (&quot;));
    DEBUG_PRINT(MPU6050_DMP_CODE_SIZE);
    DEBUG_PRINTLN(F(&quot; bytes)&quot;));
    if (!writeProgMemoryBlock(dmpMemory, MPU6050_DMP_CODE_SIZE)) return 1; // Failed
    DEBUG_PRINTLN(F(&quot;Success! DMP code written and verified.&quot;));

    // Set the FIFO Rate Divisor int the DMP Firmware Memory
    unsigned char dmpUpdate[] = {0x00, MPU6050_DMP_FIFO_RATE_DIVISOR};
    writeMemoryBlock(dmpUpdate, 0x02, 0x02, 0x16); // Lets write the dmpUpdate data to the Firmware image, we have 2 bytes to write in bank 0x02 with the Offset 0x16

    //write start address MSB into register
    setDMPConfig1(0x03);
    //write start address LSB into register
    setDMPConfig2(0x00);

    DEBUG_PRINTLN(F(&quot;Clearing OTP Bank flag...&quot;));
    setOTPBankValid(false);

    DEBUG_PRINTLN(F(&quot;Setting motion detection threshold to 2...&quot;));
    setMotionDetectionThreshold(2);

    DEBUG_PRINTLN(F(&quot;Setting zero-motion detection threshold to 156...&quot;));
    setZeroMotionDetectionThreshold(156);

    DEBUG_PRINTLN(F(&quot;Setting motion detection duration to 80...&quot;));
    setMotionDetectionDuration(80);

    DEBUG_PRINTLN(F(&quot;Setting zero-motion detection duration to 0...&quot;));
    setZeroMotionDetectionDuration(0);
    DEBUG_PRINTLN(F(&quot;Enabling FIFO...&quot;));
    setFIFOEnabled(true);

    DEBUG_PRINTLN(F(&quot;Resetting DMP...&quot;));
    resetDMP();

    DEBUG_PRINTLN(F(&quot;DMP is good to go! Finally.&quot;));

    DEBUG_PRINTLN(F(&quot;Disabling DMP (you turn it on later)...&quot;));
    setDMPEnabled(false);

    DEBUG_PRINTLN(F(&quot;Setting up internal 42-byte (default) DMP packet buffer...&quot;));
    dmpPacketSize = 42;

    DEBUG_PRINTLN(F(&quot;Resetting FIFO and clearing INT status one last time...&quot;));
    resetFIFO();
    getIntStatus();

    return 0; // success
}
inline bool MPU6050::dmpPacketAvailable() {
    return getFIFOCount() &gt;= dmpGetFIFOPacketSize();
}
inline uint8_t MPU6050::dmpGetAccel(int32_t *data, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    data[0] = (((uint32_t)packet[28] &lt;&lt; 24) | ((uint32_t)packet[29] &lt;&lt; 16) | ((uint32_t)packet[30] &lt;&lt; 8) | packet[31]);
    data[1] = (((uint32_t)packet[32] &lt;&lt; 24) | ((uint32_t)packet[33] &lt;&lt; 16) | ((uint32_t)packet[34] &lt;&lt; 8) | packet[35]);
    data[2] = (((uint32_t)packet[36] &lt;&lt; 24) | ((uint32_t)packet[37] &lt;&lt; 16) | ((uint32_t)packet[38] &lt;&lt; 8) | packet[39]);
    return 0;
}
inline uint8_t MPU6050::dmpGetAccel(int16_t *data, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    data[0] = (packet[28] &lt;&lt; 8) | packet[29];
    data[1] = (packet[32] &lt;&lt; 8) | packet[33];
    data[2] = (packet[36] &lt;&lt; 8) | packet[37];
    return 0;
}
inline uint8_t MPU6050::dmpGetAccel(VectorInt16 *v, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    v -&gt; x = (packet[28] &lt;&lt; 8) | packet[29];
    v -&gt; y = (packet[32] &lt;&lt; 8) | packet[33];
    v -&gt; z = (packet[36] &lt;&lt; 8) | packet[37];
    return 0;
}
inline uint8_t MPU6050::dmpGetQuaternion(int32_t *data, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    data[0] = (((uint32_t)packet[0] &lt;&lt; 24) | ((uint32_t)packet[1] &lt;&lt; 16) | ((uint32_t)packet[2] &lt;&lt; 8) | packet[3]);
    data[1] = (((uint32_t)packet[4] &lt;&lt; 24) | ((uint32_t)packet[5] &lt;&lt; 16) | ((uint32_t)packet[6] &lt;&lt; 8) | packet[7]);
    data[2] = (((uint32_t)packet[8] &lt;&lt; 24) | ((uint32_t)packet[9] &lt;&lt; 16) | ((uint32_t)packet[10] &lt;&lt; 8) | packet[11]);
    data[3] = (((uint32_t)packet[12] &lt;&lt; 24) | ((uint32_t)packet[13] &lt;&lt; 16) | ((uint32_t)packet[14] &lt;&lt; 8) | packet[15]);
    return 0;
}
inline uint8_t MPU6050::dmpGetQuaternion(int16_t *data, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    data[0] = ((packet[0] &lt;&lt; 8) | packet[1]);
    data[1] = ((packet[4] &lt;&lt; 8) | packet[5]);
    data[2] = ((packet[8] &lt;&lt; 8) | packet[9]);
    data[3] = ((packet[12] &lt;&lt; 8) | packet[13]);
    return 0;
}
inline uint8_t MPU6050::dmpGetQuaternion(Quaternion *q, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    int16_t qI[4];
    uint8_t status = dmpGetQuaternion(qI, packet);
    if (status == 0) {
        q -&gt; w = (float)qI[0] / 16384.0f;
        q -&gt; x = (float)qI[1] / 16384.0f;
        q -&gt; y = (float)qI[2] / 16384.0f;
        q -&gt; z = (float)qI[3] / 16384.0f;
        return 0;
    }
    return status; // int16 return value, indicates error if this line is reached
}
inline uint8_t MPU6050::dmpGetGyro(int32_t *data, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    data[0] = (((uint32_t)packet[16] &lt;&lt; 24) | ((uint32_t)packet[17] &lt;&lt; 16) | ((uint32_t)packet[18] &lt;&lt; 8) | packet[19]);
    data[1] = (((uint32_t)packet[20] &lt;&lt; 24) | ((uint32_t)packet[21] &lt;&lt; 16) | ((uint32_t)packet[22] &lt;&lt; 8) | packet[23]);
    data[2] = (((uint32_t)packet[24] &lt;&lt; 24) | ((uint32_t)packet[25] &lt;&lt; 16) | ((uint32_t)packet[26] &lt;&lt; 8) | packet[27]);
    return 0;
}
inline uint8_t MPU6050::dmpGetGyro(int16_t *data, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    data[0] = (packet[16] &lt;&lt; 8) | packet[17];
    data[1] = (packet[20] &lt;&lt; 8) | packet[21];
    data[2] = (packet[24] &lt;&lt; 8) | packet[25];
    return 0;
}
inline uint8_t MPU6050::dmpGetGyro(VectorInt16 *v, const uint8_t* packet) {
    // TODO: accommodate different arrangements of sent data (ONLY default supported now)
    if (packet == 0) packet = dmpPacketBuffer;
    v -&gt; x = (packet[16] &lt;&lt; 8) | packet[17];
    v -&gt; y = (packet[20] &lt;&lt; 8) | packet[21];
    v -&gt; z = (packet[24] &lt;&lt; 8) | packet[25];
    return 0;
}
inline uint8_t MPU6050::dmpGetLinearAccel(VectorInt16 *v, VectorInt16 *vRaw, VectorFloat *gravity) {
    // get rid of the gravity component (+1g = +8192 in standard DMP FIFO packet, sensitivity is 2g)
    v -&gt; x = vRaw -&gt; x - gravity -&gt; x*8192;
    v -&gt; y = vRaw -&gt; y - gravity -&gt; y*8192;
    v -&gt; z = vRaw -&gt; z - gravity -&gt; z*8192;
    return 0;
}
inline uint8_t MPU6050::dmpGetLinearAccelInWorld(VectorInt16 *v, VectorInt16 *vReal, Quaternion *q) {
    // rotate measured 3D acceleration vector into original state
    // frame of reference based on orientation quaternion
    memcpy(v, vReal, sizeof(VectorInt16));
    v -&gt; rotate(q);
    return 0;
}
inline uint8_t MPU6050::dmpGetGravity(int16_t *data, const uint8_t* packet) {
    /* +1g corresponds to +8192, sensitivity is 2g. */
    int16_t qI[4];
    uint8_t status = dmpGetQuaternion(qI, packet);
    data[0] = ((int32_t)qI[1] * qI[3] - (int32_t)qI[0] * qI[2]) / 16384;
    data[1] = ((int32_t)qI[0] * qI[1] + (int32_t)qI[2] * qI[3]) / 16384;
    data[2] = ((int32_t)qI[0] * qI[0] - (int32_t)qI[1] * qI[1]
           - (int32_t)qI[2] * qI[2] + (int32_t)qI[3] * qI[3]) / (2 * 16384);
    return status;
}
inline uint8_t MPU6050::dmpGetGravity(VectorFloat *v, Quaternion *q) {
    v -&gt; x = 2 * (q -&gt; x*q -&gt; z - q -&gt; w*q -&gt; y);
    v -&gt; y = 2 * (q -&gt; w*q -&gt; x + q -&gt; y*q -&gt; z);
    v -&gt; z = q -&gt; w*q -&gt; w - q -&gt; x*q -&gt; x - q -&gt; y*q -&gt; y + q -&gt; z*q -&gt; z;
    return 0;
}
inline uint8_t MPU6050::dmpGetEuler(float *data, Quaternion *q) {
    data[0] = atan2(2*q -&gt; x*q -&gt; y - 2*q -&gt; w*q -&gt; z, 2*q -&gt; w*q -&gt; w + 2*q -&gt; x*q -&gt; x - 1);   // psi
    data[1] = -asin(2*q -&gt; x*q -&gt; z + 2*q -&gt; w*q -&gt; y);                              // theta
    data[2] = atan2(2*q -&gt; y*q -&gt; z - 2*q -&gt; w*q -&gt; x, 2*q -&gt; w*q -&gt; w + 2*q -&gt; z*q -&gt; z - 1);   // phi
    return 0;
}

#ifdef USE_OLD_DMPGETYAWPITCHROLL
inline uint8_t MPU6050::dmpGetYawPitchRoll(float *data, Quaternion *q, VectorFloat *gravity) {
    // yaw: (about Z axis)
    data[0] = atan2(2*q -&gt; x*q -&gt; y - 2*q -&gt; w*q -&gt; z, 2*q -&gt; w*q -&gt; w + 2*q -&gt; x*q -&gt; x - 1);
    // pitch: (nose up/down, about Y axis)
    data[1] = atan(gravity -&gt; x / sqrt(gravity -&gt; y*gravity -&gt; y + gravity -&gt; z*gravity -&gt; z));
    // roll: (tilt left/right, about X axis)
    data[2] = atan(gravity -&gt; y / sqrt(gravity -&gt; x*gravity -&gt; x + gravity -&gt; z*gravity -&gt; z));
    return 0;
}
#else 
inline uint8_t MPU6050::dmpGetYawPitchRoll(float *data, Quaternion *q, VectorFloat *gravity) {
    // yaw: (about Z axis)
    data[0] = atan2(2*q -&gt; x*q -&gt; y - 2*q -&gt; w*q -&gt; z, 2*q -&gt; w*q -&gt; w + 2*q -&gt; x*q -&gt; x - 1);
    // pitch: (nose up/down, about Y axis)
    data[1] = atan2(gravity -&gt; x , sqrt(gravity -&gt; y*gravity -&gt; y + gravity -&gt; z*gravity -&gt; z));
    // roll: (tilt left/right, about X axis)
    data[2] = atan2(gravity -&gt; y , gravity -&gt; z);
    if (gravity -&gt; z &lt; 0) {
        if(data[1] &gt; 0) {
            data[1] = PI - data[1]; 
        } else { 
            data[1] = -PI - data[1];
        }
    }
    return 0;
}
#endif

inline uint8_t MPU6050::dmpProcessFIFOPacket(const unsigned char *dmpData) {
    return 0;
}

inline uint8_t MPU6050::dmpReadAndProcessFIFOPacket(uint8_t numPackets, uint8_t *processed) {
    uint8_t status;
    uint8_t buf[dmpPacketSize];
    for (uint8_t i = 0; i &lt; numPackets; i++) {
        // read packet from FIFO
        getFIFOBytes(buf, dmpPacketSize);

        // process packet
        if ((status = dmpProcessFIFOPacket(buf)) &gt; 0) return status;
        
        // increment external process count variable, if supplied
        if (processed != 0) (*processed)++;
    }
    return 0;
}

inline uint16_t MPU6050::dmpGetFIFOPacketSize() {
    return dmpPacketSize;
}
#endif

I don't know why the guys that made this library didn't add this. Maybe I'm missing something.