SparkFun Forums

[Matchief]

Hi,

I have a Sparkfun MMA8452Q connected to my Arduino. The code I am using prints to both the serial monitor, and an SD card on the Arduino.
My question is, how can I determine what time has elapsed based on my baud rate, and the number of lines that have been printed?

I am using Matlab to process the signal, and need to have accurate plots to show the time that has elapsed and the frequency spectrum.

If I'm using a Baud rate of 1200 (bits per second) and the Accelerometer frequency is 800 Hz, how many lines of code will it print per second? How many seconds does it take to print 400 lines?

I have tried using the number of bytes in an array of these numbers, with the baud rate, but I'm fairly new to this field and don't know if this is the right direction.

Thanks,

Here is a sample of the output:
-0.016 0.077 1.003
-0.017 0.078 1.01
-0.015 0.084 1.008
-0.016 0.084 1.01
-0.018 0.084 1.009
-0.012 0.081 1.004
-0.012 0.079 1.008
-0.016 0.078 1.005
-0.018 0.078 1.011
-0.014 0.084 1.013
-0.013 0.083 1.010.....

Below is the code:
/******************************************************************************
MMA8452Q_Basic.ino
SFE_MMA8452Q Library Basic Example Sketch
Jim Lindblom @ SparkFun Electronics
Original Creation Date: June 3, 2014
https://github.com/sparkfun/MMA8452_Accelerometer

This sketch uses the SparkFun_MMA8452Q library to initialize the
accelerometer, and stream values from it.

Hardware hookup:
Arduino --------------- MMA8452Q Breakout
3.3V --------------- 3.3V
GND --------------- GND
SDA (A4) --\/330 Ohm\/-- SDA
SCL (A5) --\/330 Ohm\/-- SCL

The MMA8452Q is a 3.3V max sensor, so you'll need to do some
level-shifting between the Arduino and the breakout. Series
resistors on the SDA and SCL lines should do the trick.

Development environment specifics:
IDE: Arduino 1.0.5
Hardware Platform: Arduino Uno

**Updated for Arduino 1.6.4 5/2015**

This code is beerware; if you see me (or any other SparkFun employee) at the
local, and you've found our code helpful, please buy us a round!

Distributed as-is; no warranty is given.
******************************************************************************/
#include <Wire.h> // Must include Wire library for I2C
#include <SparkFun_MMA8452Q.h> // Includes the SFE_MMA8452Q library
#include <SD.h>
#include <SPI.h>
#include <Adafruit_GPS.h>

File myFile;

// Begin using the library by creating an instance of the MMA8452Q
// class. We'll call it "accel". That's what we'll reference from
// here on out.
MMA8452Q accel;


// The setup function simply starts serial and initializes the
// accelerometer.
void setup()
{
Serial.begin(1200);
while(!Serial){
}
Serial.println("MMA8452Q TWR10 Accelerometer Loading \n");
Serial.println("Initializing SD Card...");

if (!SD.begin(4)) {
Serial.println("initialization failed!");
while(1);
}
Serial.println("initialization done.");

myFile = SD.open("MarchTen.txt", FILE_WRITE);
if(myFile) {
Serial.print("Writing to test.txt...");
myFile.println("//TESTING...");
myFile.close();
Serial.println("done.");
} else {
Serial.println("error opening test.txt");
}


// Choose your adventure! There are a few options when it comes
// to initializing the MMA8452Q:
// 1. Default init. This will set the accelerometer up
// with a full-scale range of +/-2g, and an output data rate
// of 800 Hz (fastest).
accel.init();
// 2. Initialize with FULL-SCALE setting. You can set the scale
// using either SCALE_2G, SCALE_4G, or SCALE_8G as the value.
// That'll set the scale to +/-2g, 4g, or 8g respectively.
//accel.init(SCALE_4G); // Uncomment this out if you'd like
// 3. Initialize with FULL-SCALE and DATA RATE setting. If you
// want control over how fast your accelerometer produces
// data use one of the following options in the second param:
// ODR_800, ODR_400, ODR_200, ODR_100, ODR_50, ODR_12,
// ODR_6, or ODR_1.
// Sets to 800, 400, 200, 100, 50, 12.5, 6.25, or 1.56 Hz.
//accel.init(SCALE_8G, ODR_200);
}

// The loop function will simply check for new data from the
// accelerometer and print it out if it's available.
void loop()
{
// Use the accel.available() function to wait for new data
// from the accelerometer.
if (accel.available())
{
// First, use accel.read() to read the new variables:
accel.read();

// accel.read() will update two sets of variables.
// * int's x, y, and z will store the signed 12-bit values
// read out of the accelerometer.
// * floats cx, cy, and cz will store the calculated
// acceleration from those 12-bit values. These variables
// are in units of g's.
// Check the two function declarations below for an example
// of how to use these variables.
printCalculatedAccels();
//printAccels(); // Uncomment to print digital readings

// The library also supports the portrait/landscape detection
// of the MMA8452Q. Check out this function declaration for
// an example of how to use that.
//printOrientation();

Serial.println(); // Print new line every time.
}
}

// The function demonstrates how to use the accel.x, accel.y and
// accel.z variables.
// Before using these variables you must call the accel.read()
// function!
void printAccels()
{
myFile = SD.open("MarchTen.txt", FILE_WRITE);
Serial.print(accel.x, 3);
myFile.println(accel.x, 3);
Serial.print("\t");
myFile.println("\t");
Serial.print(accel.y, 3);
myFile.println(accel.y, 3);
Serial.print("\t");
myFile.println("\t");
Serial.print(accel.z, 3);
myFile.println(accel.z, 3);
Serial.print("\t");
myFile.println("\t");
myFile.close();
}

// This function demonstrates how to use the accel.cx, accel.cy,
// and accel.cz variables.
// Before using these variables you must call the accel.read()
// function!
void printCalculatedAccels()
{
myFile = SD.open("MarchTen.txt", FILE_WRITE);
Serial.print(accel.cx, 3);
myFile.print(accel.cx, 3);
Serial.print("\t");
myFile.print("\t");
Serial.print(accel.cy, 3);
myFile.print(accel.cy, 3);
Serial.print("\t");
myFile.print("\t");
Serial.print(accel.cz, 3);
myFile.print(accel.cz, 3);
Serial.print("\t");
myFile.println(";...\t");
myFile.close();
}

// This function demonstrates how to use the accel.readPL()
// function, which reads the portrait/landscape status of the
// sensor.
void printOrientation()
{
// accel.readPL() will return a byte containing information
// about the orientation of the sensor. It will be either
// PORTRAIT_U, PORTRAIT_D, LANDSCAPE_R, LANDSCAPE_L, or
// LOCKOUT.
byte pl = accel.readPL();
switch (pl)
{
case PORTRAIT_U:
Serial.print("Portrait Up");
break;
case PORTRAIT_D:
Serial.print("Portrait Down");
break;
case LANDSCAPE_R:
Serial.print("Landscape Right");
break;
case LANDSCAPE_L:
Serial.print("Landscape Left");
break;
case LOCKOUT:
Serial.print("Flat");
break;
}
}