Receiveing multiple data strings from arduino HELP FAST

hello guys.
First of all sorry for a title but I have 4 hours to finish my school project.
SO my problem is that I don’t know how to read multiple values via serial port. I got it working for one value but when I add new value it doesn’t work.
here is processing code

import processing.serial.*;

Serial mySerial;
Serial myPort;

float a=0.0;
float b=0.0;

float Total_angle_x = 0;

void setup() {
  //Pozadina
  size(1000, 1000);
  background(#838383);
  
  myPort = new Serial(this, "COM3", 9600);
  myPort.bufferUntil('\n');
  
}

void serialEvent (Serial myPort){
    Total_angle_x = float(myPort.readStringUntil('\n'));
}

//Model glavnog drona
void dron_main() {
  fill(#000000);
  ellipseMode(CENTER);
    ellipse(500, 400, 300, 300);

  beginShape();
    vertex(712, 682);
    vertex(217, 187);
    vertex(287, 117);
    vertex(782, 612);
  endShape(CLOSE);

  beginShape();
    vertex(217, 612);
    vertex(712, 117);
    vertex(782, 187);
    vertex(287, 682);
  endShape(CLOSE);

    ellipse(252, 152, 100, 100);
    ellipse(747, 152, 100, 100);
    ellipse(747, 647, 100, 100);
    ellipse(252, 647, 100, 100);
}
//Model animiranog drona
void dron_anim() {
  fill(#000000);
  ellipseMode(CENTER);
    ellipse(0, 0, 70, 70);

  beginShape();
    vertex(40, -55);
    vertex(-55, 40);
    vertex(-40, 55);
    vertex(55, -40);
  endShape(CLOSE);

  beginShape();
    vertex(-55, -40);
    vertex(40, 55);
    vertex(55, 40);
    vertex(-40, -55);
  endShape(CLOSE);

    ellipse(-48, 48, 20, 20);
    ellipse(48, 48, 20, 20);
    ellipse(-48, -48, 20, 20);
    ellipse(48, -48, 20, 20);
}

void motor1() {
  fill(#FF8C00);
  rectMode(CENTER);
    rect(252, 152, 75, 15);
    fill(#C0C0C0);
    rect(252, 123, 75, 45);
    fill(#FF8C00);
    rect(252, 93, 75, 15);
    fill(#C0C0C0);
    rect(252, 70, 10, 30);
    fill(#000000);
  textSize(32);
  text("M1", 230, 134);
}

void motor2() {
  fill(#FF8C00);
  rectMode(CENTER);
    rect(747, 152, 75, 15);
    fill(#C0C0C0);
    rect(747, 123, 75, 45);
    fill(#FF8C00);
    rect(747, 93, 75, 15);
    fill(#C0C0C0);
    rect(747, 70, 10, 30);
    fill(#000000);
  textSize(32);
  text("M2", 725, 134);
}

void motor3() {
  fill(#FF8C00);
  rectMode(CENTER);
    rect(252, 647, 75, 15);
    fill(#C0C0C0);
    rect(252, 618, 75, 45);
    fill(#FF8C00);
    rect(252, 589, 75, 15);
    fill(#C0C0C0);
    rect(252, 566, 10, 30);
    fill(#000000);
  textSize(32);
  text("M3", 230, 630);
}

void motor4() {
  fill(#FF8C00);
  rectMode(CENTER);
    rect(747, 647, 75, 15);
    fill(#C0C0C0);
    rect(747, 618, 75, 45);
    fill(#FF8C00);
    rect(747, 589, 75, 15);
    fill(#C0C0C0);
    rect(747, 566, 10, 30);
    fill(#000000);
  textSize(32);
  text("M4", 725, 630);
}

void draw() {
  background(#838383);

  

  //Pravokutnici na dnu
  pushMatrix();
  rectMode(CORNERS);
    fill(#F2EF84);
    rect(0, 800, 250, 1000);
    fill(#FF7F1C);
    rect(250, 800, 500, 1000);
    fill(#6DCB4E);
    rect(500, 800, 750, 1000);
    fill(#374CCB);
    rect(750, 800, 1000, 1000);
  popMatrix();
  
  //Obrub pravokutnika     
  strokeWeight(5);
    line(250, 800, 250, 1000);
    line(500, 800, 500, 1000);
    line(750, 800, 750, 1000);
    line(999, 800, 999, 1000);
    line(0, 800, 1000, 800);
    line(0, 800, 0, 1000);
    line(0, 999, 1000, 999);
  strokeWeight(0);

  dron_main();

  motor1();
  motor2();
  motor3();
  motor4();
  
  //rotacija animiranog drona
  pushMatrix();
    translate(875, 900);
    rotate(a);
    dron_anim();
  popMatrix();
  textSize(16);
  text("Orjentacija", 830, 820);
  text("XX°", 865, 990);

  a+=.01;
  
  //rotacija y osi
  pushMatrix();
    translate(625, 900);
    rotate(a);
    strokeWeight(7);
    line(-45,0,45,0);
  popMatrix();
  textSize(16);
  text("Nagib y osi", 580, 820);
  text("XX°", 615, 990);
  
  //rotacija x osi
  pushMatrix();
    translate(375, 900);
    rotate(radians(-Total_angle_x));
    strokeWeight(7);
    line(-45,0,45,0);
  popMatrix();
  textSize(16);
  text("Nagib x osi", 330, 820);
  text(Total_angle_x, 360, 990);
  
  strokeWeight(0);
  
  //graficki prikaz throttle-a
  pushMatrix();
    translate(125, 900);
    rectMode(CENTER);
    rect(0, 100-a,100,b);
  popMatrix();
  textSize(16);
  text("Throttle", 92, 820);
  
  //vrijednost M1
  textSize(16);
  text("XXXX RPM", 100, 180);
  rect(140, 160-(b/2),30,b);
  
  //vrijednost M2
  textSize(16);
  text("XXXX RPM", 820, 180);
  rect(857, 160-(b/2),30,b);
  
  //vrijednost M3
  textSize(16);
  text("XXXX RPM", 100, 680);
  rect(140, 660-(b/2),30,b);
  
  //vrijednost M4
  textSize(16);
  text("XXXX RPM", 820, 680);
  rect(857, 660-(b/2),30,b);
  
  b+=1;
  //b+=.05;
    
  
}

and here is arduino code (but is think that it is only important for you serial.print part of code)

/* http://www.youtube.com/c/electronoobs
 * 
 * This is an example where we configure te data of the MPU6050
 * and read the Acceleration data and print it to the serial monitor
 * 
 * Arduino pin    |   MPU6050
 * 5V             |   Vcc
 * GND            |   GND
 * A4             |   SDA
 * A5             |   SCL
 */
 
//Includes
#include <Wire.h>


//Gyro Variables
float elapsedTime, time, timePrev;        //Variables for time control
int gyro_error=0;                         //We use this variable to only calculate once the gyro data error
float Gyr_rawX, Gyr_rawY, Gyr_rawZ;     //Here we store the raw data read 
float Gyro_angle_x, Gyro_angle_y;         //Here we store the angle value obtained with Gyro data
float Gyro_raw_error_x, Gyro_raw_error_y; //Here we store the initial gyro data error

//Acc Variables
int acc_error=0;                         //We use this variable to only calculate once the Acc data error
float rad_to_deg = 180/3.141592654;      //This value is for pasing from radians to degrees values
float Acc_rawX, Acc_rawY, Acc_rawZ;    //Here we store the raw data read 
float Acc_angle_x, Acc_angle_y;          //Here we store the angle value obtained with Acc data
float Acc_angle_error_x, Acc_angle_error_y; //Here we store the initial Acc data error

float Total_angle_x, Total_angle_y;



void setup() {
  Wire.begin();                           //begin the wire comunication
  
  Wire.beginTransmission(0x68);           //begin, Send the slave adress (in this case 68)              
  Wire.write(0x6B);                       //make the reset (place a 0 into the 6B register)
  Wire.write(0x00);
  Wire.endTransmission(true);             //end the transmission
  //Gyro config
  Wire.beginTransmission(0x68);           //begin, Send the slave adress (in this case 68) 
  Wire.write(0x1B);                       //We want to write to the GYRO_CONFIG register (1B hex)
  Wire.write(0x10);                       //Set the register bits as 00010000 (1000dps full scale)
  Wire.endTransmission(true);             //End the transmission with the gyro
  //Acc config
  Wire.beginTransmission(0x68);           //Start communication with the address found during search.
  Wire.write(0x1C);                       //We want to write to the ACCEL_CONFIG register
  Wire.write(0x10);                       //Set the register bits as 00010000 (+/- 8g full scale range)
  Wire.endTransmission(true); 

  Serial.begin(9600);                     //Remember to set this same baud rate to the serial monitor  
  time = millis();                        //Start counting time in milliseconds


/*Here we calculate the acc data error before we start the loop
 * I make the mean of 200 values, that should be enough*/
  if(acc_error==0)
  {
    for(int a=0; a<200; a++)
    {
      Wire.beginTransmission(0x68);
      Wire.write(0x3B);                       //Ask for the 0x3B register- correspond to AcX
      Wire.endTransmission(false);
      Wire.requestFrom(0x68,6,true); 
      
      Acc_rawX=(Wire.read()<<8|Wire.read())/4096.0 ; //each value needs two registres
      Acc_rawY=(Wire.read()<<8|Wire.read())/4096.0 ;
      Acc_rawZ=(Wire.read()<<8|Wire.read())/4096.0 ;

      
      /*---X---*/
      Acc_angle_error_x = Acc_angle_error_x + ((atan((Acc_rawY)/sqrt(pow((Acc_rawX),2) + pow((Acc_rawZ),2)))*rad_to_deg));
      /*---Y---*/
      Acc_angle_error_y = Acc_angle_error_y + ((atan(-1*(Acc_rawX)/sqrt(pow((Acc_rawY),2) + pow((Acc_rawZ),2)))*rad_to_deg)); 
      
      if(a==199)
      {
        Acc_angle_error_x = Acc_angle_error_x/200;
        Acc_angle_error_y = Acc_angle_error_y/200;
        acc_error=1;
      }
    }
  }//end of acc error calculation   


/*Here we calculate the gyro data error before we start the loop
 * I make the mean of 200 values, that should be enough*/
  if(gyro_error==0)
  {
    for(int i=0; i<200; i++)
    {
      Wire.beginTransmission(0x68);            //begin, Send the slave adress (in this case 68) 
      Wire.write(0x43);                        //First adress of the Gyro data
      Wire.endTransmission(false);
      Wire.requestFrom(0x68,4,true);           //We ask for just 4 registers 
         
      Gyr_rawX=Wire.read()<<8|Wire.read();     //Once again we shif and sum
      Gyr_rawY=Wire.read()<<8|Wire.read();
   
      /*---X---*/
      Gyro_raw_error_x = Gyro_raw_error_x + (Gyr_rawX/32.8); 
      /*---Y---*/
      Gyro_raw_error_y = Gyro_raw_error_y + (Gyr_rawY/32.8);
      if(i==199)
      {
        Gyro_raw_error_x = Gyro_raw_error_x/200;
        Gyro_raw_error_y = Gyro_raw_error_y/200;
        gyro_error=1;
      }
    }
  }//end of gyro error calculation   
}//end of setup void






void loop() {
  timePrev = time;                        // the previous time is stored before the actual time read
  time = millis();                        // actual time read
  elapsedTime = (time - timePrev) / 1000; //divide by 1000 in order to obtain seconds

  //////////////////////////////////////Gyro read/////////////////////////////////////

    Wire.beginTransmission(0x68);            //begin, Send the slave adress (in this case 68) 
    Wire.write(0x43);                        //First adress of the Gyro data
    Wire.endTransmission(false);
    Wire.requestFrom(0x68,4,true);           //We ask for just 4 registers
        
    Gyr_rawX=Wire.read()<<8|Wire.read();     //Once again we shif and sum
    Gyr_rawY=Wire.read()<<8|Wire.read();
    /*Now in order to obtain the gyro data in degrees/seconds we have to divide first
    the raw value by 32.8 because that's the value that the datasheet gives us for a 1000dps range*/
    /*---X---*/
    Gyr_rawX = (Gyr_rawX/32.8) - Gyro_raw_error_x; 
    /*---Y---*/
    Gyr_rawY = (Gyr_rawY/32.8) - Gyro_raw_error_y;
    
    /*Now we integrate the raw value in degrees per seconds in order to obtain the angle
    * If you multiply degrees/seconds by seconds you obtain degrees */
    /*---X---*/
    Gyro_angle_x = Gyr_rawX*elapsedTime;
    /*---X---*/
    Gyro_angle_y = Gyr_rawY*elapsedTime;


    
  
  //////////////////////////////////////Acc read/////////////////////////////////////

  Wire.beginTransmission(0x68);     //begin, Send the slave adress (in this case 68) 
  Wire.write(0x3B);                 //Ask for the 0x3B register- correspond to AcX
  Wire.endTransmission(false);      //keep the transmission and next
  Wire.requestFrom(0x68,6,true);    //We ask for next 6 registers starting withj the 3B  
  /*We have asked for the 0x3B register. The IMU will send a brust of register.
  * The amount of register to read is specify in the requestFrom function.
  * In this case we request 6 registers. Each value of acceleration is made out of
  * two 8bits registers, low values and high values. For that we request the 6 of them  
  * and just make then sum of each pair. For that we shift to the left the high values 
  * register (<<) and make an or (|) operation to add the low values.
  If we read the datasheet, for a range of+-8g, we have to divide the raw values by 4096*/    
  Acc_rawX=(Wire.read()<<8|Wire.read())/4096.0 ; //each value needs two registres
  Acc_rawY=(Wire.read()<<8|Wire.read())/4096.0 ;
  Acc_rawZ=(Wire.read()<<8|Wire.read())/4096.0 ; 
 /*Now in order to obtain the Acc angles we use euler formula with acceleration values
 after that we substract the error value found before*/  
 /*---X---*/
 Acc_angle_x = (atan((Acc_rawY)/sqrt(pow((Acc_rawX),2) + pow((Acc_rawZ),2)))*rad_to_deg) - Acc_angle_error_x;
 /*---Y---*/
 Acc_angle_y = (atan(-1*(Acc_rawX)/sqrt(pow((Acc_rawY),2) + pow((Acc_rawZ),2)))*rad_to_deg) - Acc_angle_error_y;    


 //////////////////////////////////////Total angle and filter/////////////////////////////////////
 /*---X axis angle---*/
 Total_angle_x = 0.98 *(Total_angle_x + Gyro_angle_x) + 0.02*Acc_angle_x;
 /*---Y axis angle---*/
 Total_angle_y = 0.98 *(Total_angle_y + Gyro_angle_y) + 0.02*Acc_angle_y;
   

 
 
 /*Uncoment the rest of the serial prines
 * I only print the Y angle value for this test */
 //Serial.print("Xº: ");
 Serial.print(Total_angle_x);
 
 Serial.print("   |   ");
 //Serial.print("Yº: ");
 Serial.println(Total_angle_y);
 //Serial.println(" ");



 
}
1 Like

why not try sending one line CSV style

1023,1023,1023

and split it in processing

See command split in the reference

thank you guys but I have seen it a bit late. I passed anyways. I’ll take month brake and then finish it cuz i have last exams for finishing high school then I’ll update you on progress with app.