/********* Pleasedontcode.com ********** Pleasedontcode thanks you for automatic code generation! Enjoy your code! - Terms and Conditions: You have a non-exclusive, revocable, worldwide, royalty-free license for personal and commercial use. Attribution is optional; modifications are allowed, but you're responsible for code maintenance. We're not liable for any loss or damage. For full terms, please visit pleasedontcode.com/termsandconditions. - Project: "Bluetooth Sensor" - Source Code NOT compiled for: Arduino Uno - Source Code created on: 2024-06-09 21:01:11 ********* Pleasedontcode.com **********/ /****** SYSTEM REQUIREMENTS *****/ /****** SYSTEM REQUIREMENT 1 *****/ /* make a bluetooth headtracker to use with opentrack */ /* software */ /****** SYSTEM REQUIREMENT 2 *****/ /* make a headtracker for use with opentrack, using */ /* the mpu6050 and hc-06 bluetooth module */ /****** END SYSTEM REQUIREMENTS *****/ /****** DEFINITION OF LIBRARIES *****/ #include #include #include //https://github.com/electroniccats/mpu6050 /****** FUNCTION PROTOTYPES *****/ void setup(void); void loop(void); void dmpDataReady(void); /***** DEFINITION OF DIGITAL INPUT PINS *****/ const uint8_t accelerometer_MPU6050_Interrupt_PIN_D2 = 2; /***** DEFINITION OF Software Serial *****/ const uint8_t bluetooth_HC05_mySerial_PIN_SERIAL_TX_A0 = A0; const uint8_t bluetooth_HC05_mySerial_PIN_SERIAL_RX_A1 = A1; const uint8_t bluetooth_HC05_mySerial_PIN_SERIAL_TX_A2 = A2; const uint8_t bluetooth_HC05_mySerial_PIN_SERIAL_RX_A3 = A3; SoftwareSerial bluetooth_HC05_mySerial1(bluetooth_HC05_mySerial_PIN_SERIAL_RX_A1, bluetooth_HC05_mySerial_PIN_SERIAL_TX_A0); SoftwareSerial bluetooth_HC05_mySerial2(bluetooth_HC05_mySerial_PIN_SERIAL_RX_A3, bluetooth_HC05_mySerial_PIN_SERIAL_TX_A2); /***** DEFINITION OF I2C PINS *****/ const uint8_t accelerometer_MPU6050_I2C_PIN_SDA_A4 = A4; const uint8_t accelerometer_MPU6050_I2C_PIN_SCL_A5 = A5; const uint8_t accelerometer_MPU6050_I2C_SLAVE_ADDRESS = 104; /****** DEFINITION OF LIBRARIES CLASS INSTANCES*****/ MPU6050 mpu(accelerometer_MPU6050_I2C_SLAVE_ADDRESS); /****** VARIABLES *****/ 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 // orientation/motion vars Quaternion q; // [w, x, y, z] quaternion container VectorFloat gravity; // [x, y, z] gravity vector float ypr[3]; // [yaw, pitch, roll] yaw/pitch/roll container and gravity vector volatile bool mpuInterrupt = false; // indicates whether MPU interrupt pin has gone high void dmpDataReady() { mpuInterrupt = true; } void setup(void) { // put your setup code here, to run once: // Initialize I2C communication Wire.begin(); Wire.setClock(400000); // Set I2C frequency to 400kHz // Initialize Serial communication for debugging Serial.begin(115200); while (!Serial); // Initialize MPU6050 Serial.println(F("Initializing I2C devices...")); mpu.initialize(); // Verify connection Serial.println(F("Testing device connections...")); Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed")); // Set up interrupt pin pinMode(accelerometer_MPU6050_Interrupt_PIN_D2, INPUT); // Initialize Bluetooth Serial communication bluetooth_HC05_mySerial1.begin(9600); bluetooth_HC05_mySerial2.begin(9600); // Initialize DMP Serial.println(F("Initializing DMP...")); devStatus = mpu.dmpInitialize(); // supply your own gyro offsets here, scaled for min sensitivity mpu.setXGyroOffset(220); mpu.setYGyroOffset(76); mpu.setZGyroOffset(-85); mpu.setZAccelOffset(1788); // 1688 factory default for my test chip // make sure it worked (returns 0 if so) if (devStatus == 0) { // turn on the DMP, now that it's ready Serial.println(F("Enabling DMP...")); mpu.setDMPEnabled(true); // enable Arduino interrupt detection Serial.print(F("Enabling interrupt detection (Arduino external interrupt ")); Serial.print(digitalPinToInterrupt(accelerometer_MPU6050_Interrupt_PIN_D2)); Serial.println(F(")...")); attachInterrupt(digitalPinToInterrupt(accelerometer_MPU6050_Interrupt_PIN_D2), 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(")")); } } void loop(void) { // 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) { // other program behavior stuff here // . // . // . // if you are really paranoid you can frequently test in between other // stuff to see if mpuInterrupt is true, and if so, "break;" from the // while() loop to immediately process the MPU data // . // . // . } // 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; mpu.dmpGetQuaternion(&q, fifoBuffer); mpu.dmpGetGravity(&gravity, &q); mpu.dmpGetYawPitchRoll(ypr, &q, &gravity); Serial.print("ypr\t"); Serial.print(ypr[0] * 180/M_PI); Serial.print("\t"); Serial.print(ypr[1] * 180/M_PI); Serial.print("\t"); Serial.println(ypr[2] * 180/M_PI); // Send data over Bluetooth bluetooth_HC05_mySerial1.print("ypr\t"); bluetooth_HC05_mySerial1.print(ypr[0] * 180/M_PI); bluetooth_HC05_mySerial1.print("\t"); bluetooth_HC05_mySerial1.print(ypr[1] * 180/M_PI); bluetooth_HC05_mySerial1.print("\t"); bluetooth_HC05_mySerial1.println(ypr[2] * 180/M_PI); bluetooth_HC05_mySerial2.print("ypr\t"); bluetooth_HC05_mySerial2.print(ypr[0] * 180/M_PI); bluetooth_HC05_mySerial2.print("\t"); bluetooth_HC05_mySerial2.print(ypr[1] * 180/M_PI); bluetooth_HC05_mySerial2.print("\t"); bluetooth_HC05_mySerial2.println(ypr[2] * 180/M_PI); } } /* END CODE */