Loading...
Logo
Processing Forum
Integration and Hardware
yan5619
yan5619

Inertial Sensor Network + Arduino Pro Mini + Processing

in Integration and Hardware  •  1 year ago  
Dear all,

I'm rather new with Arduino and Processing.

Please allow me to explain what my project is about:
I am using 3 units of Invensense MPU6000 6-axis accelerometer/gyroscope to make an inertial sensor network for gait analysis, interfaced with an Arduino Pro Mini.
The Arduino part is fine for me so far, so now comes the problem:

How do I interface it with Processing?

My aim is to acquire data from the serial port, and then plot a graph based on the values.

Data will be sent from the sensors via Arduino with Serial.write().

Thank you.

Replies(4)

yan5619
yan5619

Re: Inertial Sensor Network + Arduino Pro Mini + Processing

1 year ago
Below is the Arduino code:

Copy code
  2. #include <SPI.h>
  3. #include <math.h>

  5. #define ToD(x) (x/131)
  6. #define ToG(x) (x*9.80665/16384)

  8. #define xAxis 0
  9. #define yAxis 1
  10. #define zAxis 2

  12. #define Aoffset 0.8

  14. //--- Settings /CS pins at pins 7, 8, and 9 ---//
  15. const int ChipSelPin1 = 7;
  16. const int ChipSelPin2 = 8;
  17. const int ChipSelPin3 = 9;

  19. int time=0;
  20. int time_old=0;

  22. float angle=0;
  23. float angleX=0;
  24. float angleY=0;
  25. float angleZ=0;

  27. //--- Setup for sensors ---//
  28. void setup()
  29. {
  30.   Serial.begin(115200);  // start the serial communication at baud rate of 115200
  31.   //Serial.println("MPU-6000 Data Acquisition");
  32.     
  33.   //--- SPI settings ---//
  34.   //Serial.print("Initializing SPI Protocol...");
  35.   SPI.begin();  // start the SPI library
  36.   SPI.setClockDivider(SPI_CLOCK_DIV2);  // setting SPI at 4Mhz
  37.   SPI.setBitOrder(MSBFIRST);  // data delivered MSB first
  38.   SPI.setDataMode(SPI_MODE0);  // latched on rising edge, transitioned on falling edge, active low
  39.   //Serial.println("SPI Initialized");
  40.   delay(50);
  41.   
  42.   //--- Configure the chip select pins as output ---//
  43.   pinMode(ChipSelPin1, OUTPUT);
  44.   pinMode(ChipSelPin2, OUTPUT);
  45.   pinMode(ChipSelPin3, OUTPUT);
  46.   
  47.   ConfigureMPU6000();  // configure chip
  48. }

  50. void loop()
  51. {
  52.   //time_old=time;
  53.   Serial.write(SPIread(0x3B,ChipSelPin1)); // AcceX1
  54.   Serial.write(SPIread(0x3C,ChipSelPin1)); // AcceX1
  55.   Serial.write(SPIread(0x3D,ChipSelPin1)); // AcceY1
  56.   Serial.write(SPIread(0x3E,ChipSelPin1)); // AcceY1
  57.   Serial.write(SPIread(0x3F,ChipSelPin1)); // AcceZ1
  58.   Serial.write(SPIread(0x40,ChipSelPin1)); // AcceZ1

  60.   Serial.write(SPIread(0x3B,ChipSelPin2)); // AcceX2
  61.   Serial.write(SPIread(0x3C,ChipSelPin2)); // AcceX2
  62.   Serial.write(SPIread(0x3D,ChipSelPin2)); // AcceY2
  63.   Serial.write(SPIread(0x3E,ChipSelPin2)); // AcceY2
  64.   Serial.write(SPIread(0x3F,ChipSelPin2)); // AcceZ2
  65.   Serial.write(SPIread(0x40,ChipSelPin2)); // AcceZ2

  67.   Serial.write(SPIread(0x3B,ChipSelPin3)); // AcceX3
  68.   Serial.write(SPIread(0x3C,ChipSelPin3)); // AcceX3
  69.   Serial.write(SPIread(0x3D,ChipSelPin3)); // AcceY3
  70.   Serial.write(SPIread(0x3E,ChipSelPin3)); // AcceY3
  71.   Serial.write(SPIread(0x3F,ChipSelPin3)); // AcceZ3
  72.   Serial.write(SPIread(0x40,ChipSelPin3)); // AcceZ3

  74.   //time=micros();
  75.   //int dt=time-time_old;
  76.   //Serial.print(dt);
  77.   //Serial.print("\n");
  78. }

  80. //***********************************************************//
  81. //-----------------------------------------------------------//
  82. //---------- Self-made functions for easier coding ----------//
  83. //-----------------------------------------------------------//
  84. //***********************************************************//

  86. //------------------------------------------//
  87. //--- Function for SPI writing to sensor ---//
  88. //------------------------------------------//
  89. void SPIwrite(byte reg, byte data, int ChipSelPin)
  90. {
  91.   uint8_t dump;
  92.   digitalWrite(ChipSelPin,LOW);
  93.   dump=SPI.transfer(reg);
  94.   dump=SPI.transfer(data);
  95.   digitalWrite(ChipSelPin,HIGH);
  96. }

  98. //--------------------------------------------//
  99. //--- Function for SPI reading from sensor ---//
  100. //--------------------------------------------//
  101. uint8_t SPIread(byte reg,int ChipSelPin)
  102. {
  103.   uint8_t dump;
  104.   uint8_t return_value;
  105.   uint8_t addr=reg|0x80;
  106.   digitalWrite(ChipSelPin,LOW);
  107.   dump=SPI.transfer(addr);
  108.   return_value=SPI.transfer(0x00);
  109.   digitalWrite(ChipSelPin,HIGH);
  110.   return(return_value);
  111. }

  113. //--------------------------------------//
  114. //--- Functions for reading raw data ---//
  115. //--------------------------------------//
  116. int AcceX(int ChipSelPin)
  117. {
  118.   uint8_t AcceX_H=SPIread(0x3B,ChipSelPin);
  119.   uint8_t AcceX_L=SPIread(0x3C,ChipSelPin);
  120.   int16_t AcceX=AcceX_H<<8|AcceX_L;
  121.   return(AcceX);
  122. }

  124. int AcceY(int ChipSelPin)
  125. {
  126.   uint8_t AcceY_H=SPIread(0x3D,ChipSelPin);
  127.   uint8_t AcceY_L=SPIread(0x3E,ChipSelPin);
  128.   int16_t AcceY=AcceY_H<<8|AcceY_L;
  129.   return(AcceY);
  130. }

  132. int AcceZ(int ChipSelPin)
  133. {
  134.   uint8_t AcceZ_H=SPIread(0x3F,ChipSelPin);
  135.   uint8_t AcceZ_L=SPIread(0x40,ChipSelPin);
  136.   int16_t AcceZ=AcceZ_H<<8|AcceZ_L;
  137.   return(AcceZ);
  138. }

  140. int GyroX(int ChipSelPin)
  141. {
  142.   uint8_t GyroX_H=SPIread(0x43,ChipSelPin);
  143.   uint8_t GyroX_L=SPIread(0x44,ChipSelPin);
  144.   int16_t GyroX=GyroX_H<<8|GyroX_L;
  145.   return(GyroX);
  146. }

  148. int GyroY(int ChipSelPin)
  149. {
  150.   uint8_t GyroY_H=SPIread(0x45,ChipSelPin);
  151.   uint8_t GyroY_L=SPIread(0x46,ChipSelPin);
  152.   int16_t GyroY=GyroY_H<<8|GyroY_L;
  153.   return(GyroY);
  154. }

  156. int GyroZ(int ChipSelPin)
  157. {
  158.   uint8_t GyroZ_H=SPIread(0x47,ChipSelPin);
  159.   uint8_t GyroZ_L=SPIread(0x48,ChipSelPin);
  160.   int16_t GyroZ=GyroZ_H<<8|GyroZ_L;
  161.   return(GyroZ);
  162. }

  165. //-------------------------------------------//
  166. //--- Function to initialize MPU6000 chip ---//
  167. //-------------------------------------------//
  168. void ConfigureMPU6000()
  169. {
  170.   //Serial.println("Configuring sensors......");
  171.   // DEVICE_RESET @ PWR_MGMT_1, reset device
  172.   SPIwrite(0x6B,0x80,ChipSelPin1);
  173.   delay(150);
  174.   SPIwrite(0x6B,0x80,ChipSelPin2);
  175.   delay(150);
  176.   SPIwrite(0x6B,0x80,ChipSelPin3);
  177.   delay(150);
  178.   // TEMP_DIS @ PWR_MGMT_1, wake device and select GyroZ clock
  179.   SPIwrite(0x6B,0x03,ChipSelPin1);
  180.   delay(150);
  181.   SPIwrite(0x6B,0x03,ChipSelPin2);
  182.   delay(150);
  183.   SPIwrite(0x6B,0x03,ChipSelPin3);
  184.   delay(150);
  185.   // I2C_IF_DIS @ USER_CTRL, disable I2C interface
  186.   SPIwrite(0x6A,0x10,ChipSelPin1);
  187.   delay(150);
  188.   SPIwrite(0x6A,0x10,ChipSelPin2);
  189.   delay(150);
  190.   SPIwrite(0x6A,0x10,ChipSelPin3);
  191.   delay(150);
  192.   // SMPRT_DIV @ SMPRT_DIV, sample rate at 1000Hz
  193.   SPIwrite(0x19,0x00,ChipSelPin1);
  194.   delay(150);
  195.   SPIwrite(0x19,0x00,ChipSelPin2);
  196.   delay(150);
  197.   SPIwrite(0x19,0x00,ChipSelPin3);
  198.   delay(150);
  199.   // DLPF_CFG @ CONFIG, digital low pass filter at 42Hz
  200.   SPIwrite(0x1A,0x03,ChipSelPin1);
  201.   delay(150);
  202.   SPIwrite(0x1A,0x03,ChipSelPin2);
  203.   delay(150);
  204.   SPIwrite(0x1A,0x03,ChipSelPin3);
  205.   delay(150);
  206.   // FS_SEL @ GYRO_CONFIG, gyro scale at 250dps
  207.   SPIwrite(0x1B,0x00,ChipSelPin1);
  208.   delay(150);
  209.   SPIwrite(0x1B,0x00,ChipSelPin2);
  210.   delay(150);
  211.   SPIwrite(0x1B,0x00,ChipSelPin3);
  212.   delay(150);
  213.   // AFS_SEL @ ACCEL_CONFIG, accel scale at 2g (1g=8192)
  214.   SPIwrite(0x1C,0x00,ChipSelPin1);
  215.   delay(150);
  216.   SPIwrite(0x1C,0x00,ChipSelPin2);
  217.   delay(150);
  218.   SPIwrite(0x1C,0x00,ChipSelPin3);
  219.   delay(150);
  220.   // DATA_RDY_EN @ INT_ENABLE, enable Data Ready interrupt
  221.   SPIwrite(0x38,0x01,ChipSelPin1);
  222.   delay(150);
  223.   SPIwrite(0x38,0x01,ChipSelPin2);
  224.   delay(150);
  225.   SPIwrite(0x38,0x01,ChipSelPin3);
  226.   delay(150);
  227.   // INT_RD_CLEAR @ INT_PIN_CFG, interrupt cleared on any read operation
  228.   SPIwrite(0x37,0x10,ChipSelPin1);
  229.   delay(150);
  230.   SPIwrite(0x37,0x10,ChipSelPin2);
  231.   delay(150);
  232.   SPIwrite(0x37,0x10,ChipSelPin3);
  233.   delay(150);
  234.   //Serial.println("Sensors configured");
  235. }
benja
benja

Re: Inertial Sensor Network + Arduino Pro Mini + Processing

1 year ago
Hey,

you can use serialEvent() to read the data in processing.
I usually use print() / println() to send the data, because it's easier to seperate the values, when you have strings.
So my advice is to send the values seperated by spaces and a linebreak at the end.
Then in processing you can read one line at a time and split it into the single values. An example:
Copy code
  1. import processing.serial.*;
    Serial port;

    void setup() {
      println(Serial.list());
      // you might have to pick a different serial-port here
      port = new Serial(this, Serial.list()[0], 9600);
    }

    void draw() {
      // do what ever you want here
    }

    // serial event
    void serialEvent(Serial p) {
      // get message till line break (ASCII > 13)
      String message = p.readStringUntil(13);
      // just if there is data
      if (message != null) {

        String[] elements;
        // try catch function because of possible garbage in received data
        try {
          elements = splitTokens(message);
          // loop through sensor values
          for (int i =0; i < elements.length && i < elements.length; i++ ) {
            print(int(elements[i]));
            print(" ");
          }
          println();
        }
        catch (Exception e) {
        }
      }
    }

yan5619
yan5619

Re: Inertial Sensor Network + Arduino Pro Mini + Processing

1 year ago
Hi Benja,

Thank you so much for your help and swift reply.

The reason I was using Serial.write() rather than Serial.print() in Arduino is due to the fact the Serial.print() slows the system down, while I need a much fast sampling rate (200Hz).
benja
benja

Re: Inertial Sensor Network + Arduino Pro Mini + Processing

1 year ago
Sure sending pure bytes can be a bit faster, but you have the problem how to seperate the values. Because you can't know at what point processing connects to the serial-port, it could happen that the first byte you recieve is not the first value from your sensor. Therefore you would have to send a special byte-value in between every set of values to mark the end of a message. And this might be a problem if the values from your sensor can also become the value that you are sending as seperator.

Maybe you could change your arduino code, so that it waits until processing is ready to recieve data and sends some command. And then start sending the values.

Did you really notice a big slowdown, when using print()? When picking a high baud-rate, e.g. 115200, and want to send values 200 times a second, you still have 576 symbols for your message, which should be more than enough for the 12 sensor-vaules.
What you should not try is to trace all recieved values in processing, because that can really slow down the system.
Top Reply

Statistics

  • 4 Replies
  • 434  Views
  • 0 Followers

Tags

No tags available for this topic.

Actions

Related Posts