Transmettre une valeur d'une carte a une autre puis sur Processing

Bonjour.

Mon projet est d’envoyer des informations d’une carte Arduino avec un module XBee installée sur une voiture à une autre carte Arduino similaire connectée sur un ordinateur et d’afficher les informations sur Processing. Elle envoi la tension de la batterie, le courant et la vitesse.
Mon programme me permet d’envoyer ces information de la carteVoiture sur ma cartePC mais je n’arrive pas a les récupérées et les retransmettrent sur Processing depuis la cartePC. Je n’ai pas de problèmes pour envoyer des valeurs a Processing depuis la cartePC et de les afficher mais je ne trouve pas le moyen de réutiliser les valeurs de la carteVoiture même si je les reçois sur le moniteur série.

Pour faire simple:
carteVoiture => envoi infos => cartePC => envoi infos => Processing => afficher infos

Comment attribuer la valeur d’une variable depuis une carte à une autre variable d’une carte différente par XBee?

Le programme d’envoi:

int capteur=0,nb=0;
int tour = 0,distance_total=0,vitesse=0;
float tension2 = 0;
int courant = 0;
int courant2 = 0;
float t1=0,t2=0,T=0;


void setup() {
  Serial.begin(9600);
  pinMode(8,INPUT);  //impulsions liées à la rotation de l'arbre de transmission
  digitalWrite(8,HIGH);
 }

void loop() {
 
  courant= analogRead(A5);
   Serial.print("courant=");
   courant2= (analogRead(A5)*5000)/1023;
   courant= 6*(courant2-2.5)/(3*0.625);
   Serial.println(courant);
 
 Serial.print("tension=");
 tension2=analogRead(A1); 
 tension2=5*((5000*analogRead(A1))/1023)/1000;
 Serial.println(tension2);
 Serial.println("");
 Serial.println("");
 
 Serial.print("courant=");
 courant= analogRead(A5);
 
capteur=digitalRead(8);

if (capteur==HIGH) {
                   nb=nb+1;
                   t2=millis();
                   T=t2-t1;
                   t1=t2;
                   Serial.println(nb) ;    
                   //Serial.println(nb/4); //tour axe                                                                                                                                                                                                                                                                   
                    Serial.print("T=");
                   Serial.println(T); //intervalle de temps entre deux impulsions
                    Serial.print("v=");
                   Serial.println(((0.2/T)*1000)*3.6);

                   
                  while( digitalRead(8) == HIGH) {}
                  distance_total= distance_total+0.2;
                }

Le programme reçevant:

String inputString = "";         // a string to hold incoming data
boolean stringComplete = false;  // whether the string is complete
int Jojo; 
int vitesse;
int tension;
int courant;






void setup() {
  Serial.begin(9600);
  inputString.reserve(200);
}

void loop() {  
  
  Serial.println("vitesse"+String(vitesse)+"_tension"+String(tension)+"_courant"+String(courant));
  delay(1000);
  if (stringComplete) {
    Serial.println(inputString);
    inputString = "";
    stringComplete = false;
  }
}


void serialEvent() {
  while (Serial.available()) {
     char inChar = (char)Serial.read(); 
    inputString = inputString + inChar;
    // if the incoming character is a newline, set a flag
    // so the main loop can do something about it:
    if (inChar == '\n') {
      stringComplete = true;}
}
}

Voila le processing si sa peut aider:

import processing.serial.*; 

Serial communicationARDUINO;

PFont f;
String inString="toto000";
long valeur_A=0,valeur_B=0,valeur_C=0;

void setup() {
  size(650, 550);
 
 communicationARDUINO = new Serial(this, Serial.list()[1], 9600);
 communicationARDUINO.bufferUntil(10); 
 
  strokeWeight(9);
  stroke(255, 100);
    f = loadFont("Arial-BoldMT-25.vlw");
  
  //f = createFont("Arial",25,true);
  textFont(f,25);
}

void draw() {
  fill(0);
  rect(5,100,150,100);
  rect(5,250,150,100);
  rect(5,400,150,100);
  rect(345,100,150,100);
  rect(345,250,150,100);
  rect(345,400,150,100);
  
  textAlign(LEFT);
  text("Vitesse (m/s)",5,90); 
  textAlign(LEFT);
  text("Tension (V)",5,240);
  textAlign(LEFT);
  text("Courant (A)",5,390);
  textAlign(LEFT);
  text("VOITURE TAMYA",200,50);
  textAlign(LEFT);
  text("Accélération (m/s^2)",345,90);
  textAlign(LEFT);
  text("Capacité Batterie (A.h)",345,240);
  textAlign(LEFT);
  text("Distance Parcourue (m)",345,390);
  textAlign(LEFT);
  text("VOITURE TAMYA",200,50);
  
  noStroke();
  noFill();
  
  fill(255);
  text("val = "+valeur_A,25,150);
  text("val = "+valeur_B,25,300);
  text("val = "+valeur_C,25,450);
  
  /*println(valeur_A);
  println(valeur_B);
  println(valeur_C);*/
 
 //fill(255,0,0);
 //ellipse (10,valeur_A,20,20); 
  
}







void serialEvent(Serial p) {        // permet de capturer automatiquement la chaine (String) de caractères envoyés par le serial.println de l'arduino 
 
  inString = p.readString(); 
  acquisition_valeurs();
}


void acquisition_valeurs() {
  
  int B = inString.indexOf("B");
  int C = inString.indexOf("C");
  int D = inString.indexOf("D");
  //int E = inString.indexOf("E");
  //int F = inString.indexOf("F");

  valeur_A=0;   
  for ( int i=1;i<B;i++  ) {
    valeur_A = valeur_A + (int)(pow(10,B-i-1))*(inString.charAt(i)-48); //somme avec affectation des poids à chaque chiffre
   }
 
  valeur_B=0;   
  for ( int i=B+1;i<C;i++  ) {
    valeur_B = valeur_B + (int)(pow(10,C-i-1))*(inString.charAt(i)-48); //somme avec affectation des poids à chaque chiffre
   }

  valeur_C=0;   
  for ( int i=C+1;i<D;i++  ) {
    valeur_C = valeur_C + (int)(pow(10,D-i-1))*(inString.charAt(i)-48); //somme avec affectation des poids à chaque chiffre
   }
/*
valeur_D=0;   
  for ( int i=D+1;i<E;i++  ) {
    valeur_D = valeur_D + (int)(pow(10,E-i-1))*(inString.charAt(i)-48); //somme avec affectation des poids à chaque chiffre
   }

 valeur_E=0;   
  for ( int i=E+1;i<F;i++  ) {
    valeur_E = valeur_E + (int)(pow(10,F-i-1))*(inString.charAt(i)-48); //somme avec affectation des poids à chaque chiffre
   }*/


   
}

Y a plus simple...

Carte voiture >> Xbee >> Xbee dongle >> pc >> Processing

En faisant comme ça tu évite déjà un intermédiaire.