Add wave detector

earthquake/earthquake.ino

 #include <LiquidCrystal.h>
+#include "I2Cdev.h"
+#include "MPU6050_6Axis_MotionApps20.h"
+#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
+    #include "Wire.h"
+#endif
 
 //LCD
 LiquidCrystal lcd(0, 1, 8, 9, 10, 11); /// REGISTER SELECT PIN,ENABLE PIN,D4 PIN,D5 PIN, D6 PIN, D7 PIN
 
 //SEVEN SEGMENT
-const int latchPin = 2; //to IC pin 12
+const int latchPin = 7; //to IC pin 12
 const int dataPin = 3; //to IC pin 14
 const int clockPin = 4; //to IC pin 11
 const int seismicPin = A0;
@@ -13,6 +18,34 @@ byte magnitude;
 int lastSeismoDetected;
 int loopNumber;
 
+//ACCELEROMETER/GYRO
+MPU6050 mpu;
+#define OUTPUT_READABLE_WORLDACCEL
+#define INTERRUPT_PIN 2  // use pin 2 on Arduino Uno & most boards
+#define LED_PIN 13 // (Arduino is 13, Teensy is 11, Teensy++ is 6)
+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
+// 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
+VectorInt16 aaWorldPrev;    // [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;
+}
+
 void setup() {
   //SEVEN SEGMENT
   pinMode(latchPin, OUTPUT);
@@ -26,36 +59,163 @@ void setup() {
   //LCD
   lcd.begin(16, 2);
 
-  Serial.begin(9600);
+  //ACCELEROMETER/GYRO
+  // join I2C bus (I2Cdev library doesn't do this automatically)
+  #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
+      Wire.begin();
+      Wire.setClock(400000); // 400kHz I2C clock. Comment this line if having compilation difficulties
+  #elif I2CDEV_IMPLEMENTATION == I2CDEV_BUILTIN_FASTWIRE
+      Fastwire::setup(400, true);
+  #endif
+  // initialize serial communication
+  // (115200 chosen because it is required for Teapot Demo output, but it's
+  // really up to you depending on your project)
+  Serial.begin(115200);
+  while (!Serial); // wait for Leonardo enumeration, others continue immediately
+  // NOTE: 8MHz or slower host processors, like the Teensy @ 3.3V or Arduino
+  // Pro Mini running at 3.3V, cannot handle this baud rate reliably due to
+  // the baud timing being too misaligned with processor ticks. You must use
+  // 38400 or slower in these cases, or use some kind of external separate
+  // crystal solution for the UART timer.
+  // initialize device
+  Serial.println(F("Initializing I2C devices..."));
+  mpu.initialize();
+  pinMode(INTERRUPT_PIN, INPUT);
+  // verify connection
+  Serial.println(F("Testing device connections..."));
+  Serial.println(mpu.testConnection() ? F("MPU6050 connection successful") : F("MPU6050 connection failed"));
+  
+  // load and configure the 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.println(F("Enabling interrupt detection (Arduino external interrupt 0)..."));
+      attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), 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);
+
+}
+
+bool change(VectorInt16 prev, VectorInt16 curr){
+  int offset = 500;
+  return (abs(prev.x-curr.x)>offset || abs(prev.y-curr.y)>offset || abs(prev.z-curr.z)>offset);
 }
 
 void loop() {  
   loopNumber++;
   
-  //SEVEN SEGMENT
-  digitalWrite(latchPin, LOW);
-  shiftOut(dataPin, clockPin, MSBFIRST, digit[magnitude]);
-  digitalWrite(latchPin, HIGH);
-  magnitude = (magnitude+1)%10;
-  delay(250);
+//  //SEVEN SEGMENT
+//  digitalWrite(latchPin, LOW);
+//  shiftOut(dataPin, clockPin, MSBFIRST, digit[9]);
+//  digitalWrite(latchPin, HIGH);
+//  magnitude = (magnitude+1)%10;
+//  delay(250);
 
-  //LCD
-  lcd.print("   circuit digest");//print name
-  lcd.setCursor(0, 1); // set the cursor to column 0, line 2
-  lcd.print("ic tronic");//print name
-  delay(250);//delay of 0.75sec
-  lcd.scrollDisplayLeft();//shifting data on LCD
-  lcd.setCursor(0, 0);// set the cursor to column 0, line1
-
-  int measurement = analogRead(seismicPin);
-  float seismoMag = measurement / 2000000000.0 * 5.0;
-  Serial.print("measurment = "); Serial.println(measurement);
-  Serial.print("magnitude = "); Serial.println(seismoMag);
-  if (seismoMag > 2 && loopNumber - lastSeismoDetected > 10000) {
-    lastSeismoDetected = loopNumber;
-    // detected
-    // send post to http://jauhararifin.cf:8888/api/earthquakes
-    // header : content-type = application/x-www-form-urlencoded
-    // data = "lat=1&long=1&date=2016-12-06 PM 22:03:36.000Z&strength=" + seismoMag
+//  //LCD
+//  lcd.print("   circuit digest");//print name
+//  lcd.setCursor(0, 1); // set the cursor to column 0, line 2
+//  lcd.print("ic tronic");//print name
+//  delay(250);//delay of 0.75sec
+//  lcd.scrollDisplayLeft();//shifting data on LCD
+//  lcd.setCursor(0, 0);// set the cursor to column 0, line1
+
+//  int measurement = analogRead(seismicPin);
+//  float seismoMag = measurement / 2000000000.0 * 5.0;
+//  Serial.print("measurment = "); Serial.println(measurement);
+//  Serial.print("magnitude = "); Serial.println(seismoMag);
+//  if (seismoMag > 2 && loopNumber - lastSeismoDetected > 10000) {
+//    lastSeismoDetected = loopNumber;
+//    // detected
+//    // send post to http://jauhararifin.cf:8888/api/earthquakes
+//    // header : content-type = application/x-www-form-urlencoded
+//    // data = "lat=1&long=1&date=2016-12-06 PM 22:03:36.000Z&strength=" + seismoMag
+//  }
+
+  //ACCELERO/GYRO
+  // 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;
+
+      #ifdef OUTPUT_READABLE_WORLDACCEL
+          // display initial world-frame acceleration, adjusted to remove gravity
+          // and rotated based on known orientation from quaternion
+          mpu.dmpGetQuaternion(&q, fifoBuffer);
+          mpu.dmpGetAccel(&aa, fifoBuffer);
+          mpu.dmpGetGravity(&gravity, &q);
+          mpu.dmpGetLinearAccel(&aaReal, &aa, &gravity);
+          mpu.dmpGetLinearAccelInWorld(&aaWorld, &aaReal, &q);
+          Serial.print("aworld\t");
+          Serial.print(aaWorld.x);
+          Serial.print("\t");
+          Serial.print(aaWorld.y);
+          Serial.print("\t");
+          Serial.println(aaWorld.z);
+      #endif
+
+      // blink LED to indicate activity
+      digitalWrite(LED_PIN, change(aaWorldPrev,aaWorld));
+      aaWorldPrev = aaWorld;
+      
   }
 }