Gcom communication Pi Arduino.

Coucou les maker's, petit résumé du moment, j'arrive maintenant à envoyer plusieurs valeurs d'une structure via un union depuis arduino envoyé à pi, et pi avec la rs232 récupère tous se petit monde pour le redistribuer dans une structure

 

Pleins de tests encore à faire

...et c'est pas fini...

Plop all, j'avais une tite question, le convertisseur logique est il sensible aux ondes ??

 

Mon portable est à quelques cm du convertisseur et par moment, pas tous le temps j'ai comme des parasites sur mes données, et ça revient aussitôt.

Vais tester avec le portable bien loin et faire tourner le programme

je pense pas que ça soit le convertisseur mais les fils ... Un long fil c'est une antenne ...  

Donc faut du câble blindé ?

Plop

 

Bon j'en conclue qu'il me faut du câble blindé

 

J'ai tout de même plusieurs questions :

 

- J'aimerais pouvoir gérer le temps en millis() et non avec delay() coté arduino, mais je n'ai pas vraiment réussi je dois m'embrouiller dans les ms et seconde.

- Je demande aux maîtres Jedi du C++, là, je peux attaquer maintenant les classes et fonctions, ou y a t'il quelque chose de mieux pour gérer tous ça ?

- Est il possible d'établir un canal pour l'envoie et un pour la réception, car actuellement si les deux se croisent ça merdouille.

- Est ce que je peux utiliser une adresse mémoire de Pi qu'Arduino puisse récupérer ??

Genre j'ai un pointeur sur un tableau qui doit passer par le buffer, ce tableau est donc une adresse mémoire, et dire à arduino qu'il récupère ce que contient l'adresse mémoire en question ?

Cela pourrait peut être m'éviter les embrouilles sur le flux, non ??

 

J'aurais surement d'autres questions, là je post au plus vite

 

Petite avancé quand même :

 

Gcom.cpp

#include <iostream> //Permet d'utiliser In et Out du moniteur série
#include "rs232.h"  //Librairie de communication RS232

using namespace std;

//Conseil : placez vos types du plus gros au plus petit selon les bytes
//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM
{
    //Structure pour l'émission
    struct SEN
    {
        int intform ;           //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
        float floatform ;       //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
        short int shortintform ;//2 octet/bytes (16 bits) : -32 768 / +32 767
        char charform ;         //1 octet/bytes (8 bits)  : -128 / +127
        char charform2 ;        //1 octet/bytes (8 bits)  : -128 / +127
    } dataSen;

    //Structure pour la récepetion
    struct REC
    {
        int intard;             //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
        float floatard;         //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
        short int shortintard;  //2 octet/bytes (16 bits) : -32 768 / +32 767
        char charard;           //1 octet/bytes (8 bits)  : -128 / +127
       
       
    } dataRec;

    //L'envoie et la réception sont dans des tableaux
    //(sizeof) permet de récupérer la taille en byte de nos structures
    unsigned char dataSend[sizeof (dataSen)];
    unsigned char dataReceive[sizeof (dataRec)];

}piSend, piReceive;

int BUF_SIZE = sizeof (piSend.dataSend);
int BUF_SIZEREC = sizeof (piReceive.dataReceive);

int main()
{
    //initisialisation de notre structure pour l'émission - dataSen
    piSend.dataSen.intform = 123;
    piSend.dataSen.floatform = 3.14;
    piSend.dataSen.shortintform = 15210;
    piSend.dataSen.charform = 70;       //Code ascii 70 vaut F
    piSend.dataSen.charform2 = 73;      //Code ascii 73 vaut I
  
    int cport_nr(0);                    // 0 = ttyS0
    int bdrate(115200);                 // Baud
    char mode []={'8','N','1',0};       // 8 data bits, no parity, 1 stop bit

    //Si toutes les conditions recquises sont bonnes, on ouvre le port de communication
    if (RS232_OpenComport(cport_nr, bdrate, mode))
    {
        cout <<"Ne peut pas ouvrir le port com. \n";
        return 0;
    }
    cout << "----- \n";
    cout << "Raspberry connecté : \n";
    cout << "----- \n";

    while(1)
    { 
        //Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi
        //Via la RS232
        RS232_SendBuf(cport_nr, piSend.dataSend, BUF_SIZE);
        cout << "----- \n";

        //Récupére un tableau de données de la pi dans le buffer envoyé d'Arduino
        //Via la RS232
        int n = RS232_PollComport(cport_nr, piReceive.dataReceive, BUF_SIZEREC);

        if (n > 0)
        {
            piReceive.dataReceive[n] = 0;
            cout <<"Pi reçoit d'Arduino : "<< n <<" bytes. \n";
        }

        //On regarde ce qu'Arduino nous envoit
        cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.intard <<" \n";
        cout << "Pi reçoit d'Arduino le float : " << piReceive.dataRec.floatard <<" \n";
        cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.shortintard <<" \n";
        cout << "Pi reçoit d'Arduino le char : " << piReceive.dataRec.charard <<" \n";       
       
        cout << "Taille sizeof piReceive.dataReceive : " << sizeof(piReceive.dataRec) << " octets/bytes. \n";
        cout << "\n";
        usleep(100000); //usleep est en ms  100000 pause pour 100 milliSeconds
    }

    return 0;
}

Arduino envoit : 

//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM{

  //Structure pour l'émission
  struct SEN
  {
    //taille de notre structure 11 bytes
    long ardlong ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float ardfloat;     //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int ardint;         //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte ardchar;       //1 octet/bytes (8 bits)  : -128 / +127
   
  }dataSen;

  //Structure pour la récepetion
  struct REC
  {
    //taille de notre structure 12 bytes
    long intform ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float floatform ;   //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int shortintform ;  //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte charform ;     //1 octet/bytes (8 bits)  : -128 / +127
    byte charform2 ;    //1 octet/bytes (8 bits)  : -128 / +127    
   
  }dataRec;

  //L'envoie et la réception sont dans des tableaux
  //(sizeof) permet de récupérer la taille en byte de nos structures
  unsigned char dataSend[sizeof dataSen];  
  unsigned char dataRece[sizeof dataRec]; 
 
}ardSend, ardRec;


void setup(){
  Serial.begin (115200);
 
  //Initisalisation de notre structure dataSen
  ardSend.dataSen.ardlong = 1234567891;
  ardSend.dataSen.ardfloat = 128.354;
  ardSend.dataSen.ardint = 16569;
  ardSend.dataSen.ardchar = 120;
 
}

void loop() {

  //Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi
  Serial.write (ardSend.dataSend, sizeof ardSend.dataSend);
 
  delay(100);
}

Pi reçoit :

-----
Raspberry connecté :
-----
-----
Pi reçoit d'Arduino : 7 bytes.
Pi reçoit d'Arduino le short int : 1124096672
Pi reçoit d'Arduino le float : 1.10435e-38
Pi reçoit d'Arduino le short int : 0
Pi reçoit d'Arduino le char :
Taille sizeof piReceive.dataReceive : 12 octets/bytes.

Pour l'envoi le Gcom.cpp ne change pas, vous retrouverez les valeurs initialisés dans le code :

//initisialisation de notre structure pour l'émission - dataSen
piSend.dataSen.intform = 123;
piSend.dataSen.floatform = 3.14;
piSend.dataSen.shortintform = 15210;
piSend.dataSen.charform = 70;       //Code ascii 70 vaut F
piSend.dataSen.charform2 = 73;      //Code ascii 73 vaut I

Arduino reçoit :

//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM{

  //Structure pour l'émission
  struct SEN
  {
    //taille de notre structure 11 bytes
    long ardlong ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float ardfloat;     //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int ardint;         //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte ardchar;       //1 octet/bytes (8 bits)  : -128 / +127
   
  }dataSen;

  //Structure pour la récepetion
  struct REC
  {
    //taille de notre structure 12 bytes
    long intform ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float floatform ;   //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int shortintform ;  //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte charform ;     //1 octet/bytes (8 bits)  : -128 / +127
    byte charform2 ;    //1 octet/bytes (8 bits)  : -128 / +127    
   
  }dataRec;

  //L'envoie et la réception sont dans des tableaux
  //(sizeof) permet de récupérer la taille en byte de nos structures
  unsigned char dataSend[sizeof dataSen];  
  unsigned char dataRece[sizeof dataRec]; 
 
}ardSend, ardRec;

void setup(){
  Serial.begin (115200);
 
  //Initisalisation de notre structure dataSen
  ardSend.dataSen.ardlong = 1234567891;
  ardSend.dataSen.ardfloat = 128.354;
  ardSend.dataSen.ardint = 16569;
  ardSend.dataSen.ardchar = 120;
 
}

void loop() {
 
  //Récupére un tableau de données de la pi dans le buffer que l'on initialise dans dataRec
  while (Serial.available() > 0) { //if any data available

    Serial.readBytes (ardRec.dataRece, sizeof ardRec.dataRec);

    Serial.println ("Arduino reçoit Pi ");
    Serial.print ("Intform : ");
    Serial.println (ardRec.dataRec.intform);
    Serial.print ("Floatform : ");
    Serial.println (ardRec.dataRec.floatform);
    Serial.print ("Shortintform : ");
    Serial.println (ardRec.dataRec.shortintform);
    Serial.print ("Charform : ");
    Serial.println (ardRec.dataRec.charform);
    Serial.print ("Charform2 : ");
    Serial.println (ardRec.dataRec.charform2);
    Serial.print ("-----");
   
  }

  delay(100);
}

Arduino reçoit (console) :

-----Arduino reçoit Pi
Intform : 123
Floatform : 3.14
Shortintform : 15210
Charform : 70
Charform2 : 73

En tout cas content de voir ça.
Tu peux trouver du câble blindé en recyclant un câble usb. Mais si tu as vraiment des pb avec ça, il faut mettre tout ton circuit dans une cage. Pas uniquement le câble.

J'ai posté une nouvelle question.

 

Ok, donc je récupérer l'ensemble d'un cable USB, ok à tester des que je peux

 

Plop

 

Bon j'en conclue qu'il me faut du câble blindé

 

J'ai tout de même plusieurs questions :

 

- J'aimerais pouvoir gérer le temps en millis() et non avec delay() coté arduino, mais je n'ai pas vraiment réussi je dois m'embrouiller dans les ms et seconde.

- Je demande aux maîtres Jedi du C++, là, je peux attaquer maintenant les classes et fonctions, ou y a t'il quelque chose de mieux pour gérer tous ça ?

- Est il possible d'établir un canal pour l'envoie et un pour la réception, car actuellement si les deux se croisent ça merdouille.

- Est ce que je peux utiliser une adresse mémoire de Pi qu'Arduino puisse récupérer ??

Genre j'ai un pointeur sur un tableau qui doit passer par le buffer, ce tableau est donc une adresse mémoire, et dire à arduino qu'il récupère ce que contient l'adresse mémoire en question ?

Cela pourrait peut être m'éviter les embrouilles sur le flux, non ??

 

J'aurais surement d'autres questions, là je post au plus vite

 

Petite avancé quand même :

 

Gcom.cpp

#include <iostream> //Permet d'utiliser In et Out du moniteur série
#include "rs232.h"  //Librairie de communication RS232

using namespace std;

//Conseil : placez vos types du plus gros au plus petit selon les bytes
//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM
{
    //Structure pour l'émission
    struct SEN
    {
        int intform ;           //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
        float floatform ;       //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
        short int shortintform ;//2 octet/bytes (16 bits) : -32 768 / +32 767
        char charform ;         //1 octet/bytes (8 bits)  : -128 / +127
        char charform2 ;        //1 octet/bytes (8 bits)  : -128 / +127
    } dataSen;

    //Structure pour la récepetion
    struct REC
    {
        int intard;             //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
        float floatard;         //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
        short int shortintard;  //2 octet/bytes (16 bits) : -32 768 / +32 767
        char charard;           //1 octet/bytes (8 bits)  : -128 / +127
       
       
    } dataRec;

    //L'envoie et la réception sont dans des tableaux
    //(sizeof) permet de récupérer la taille en byte de nos structures
    unsigned char dataSend[sizeof (dataSen)];
    unsigned char dataReceive[sizeof (dataRec)];

}piSend, piReceive;

int BUF_SIZE = sizeof (piSend.dataSend);
int BUF_SIZEREC = sizeof (piReceive.dataReceive);

int main()
{
    //initisialisation de notre structure pour l'émission - dataSen
    piSend.dataSen.intform = 123;
    piSend.dataSen.floatform = 3.14;
    piSend.dataSen.shortintform = 15210;
    piSend.dataSen.charform = 70;       //Code ascii 70 vaut F
    piSend.dataSen.charform2 = 73;      //Code ascii 73 vaut I
  
    int cport_nr(0);                    // 0 = ttyS0
    int bdrate(115200);                 // Baud
    char mode []={'8','N','1',0};       // 8 data bits, no parity, 1 stop bit

    //Si toutes les conditions recquises sont bonnes, on ouvre le port de communication
    if (RS232_OpenComport(cport_nr, bdrate, mode))
    {
        cout <<"Ne peut pas ouvrir le port com. \n";
        return 0;
    }
    cout << "----- \n";
    cout << "Raspberry connecté : \n";
    cout << "----- \n";

    while(1)
    { 
        //Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi
        //Via la RS232
        RS232_SendBuf(cport_nr, piSend.dataSend, BUF_SIZE);
        cout << "----- \n";

        //Récupére un tableau de données de la pi dans le buffer envoyé d'Arduino
        //Via la RS232
        int n = RS232_PollComport(cport_nr, piReceive.dataReceive, BUF_SIZEREC);

        if (n > 0)
        {
            piReceive.dataReceive[n] = 0;
            cout <<"Pi reçoit d'Arduino : "<< n <<" bytes. \n";
        }

        //On regarde ce qu'Arduino nous envoit
        cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.intard <<" \n";
        cout << "Pi reçoit d'Arduino le float : " << piReceive.dataRec.floatard <<" \n";
        cout << "Pi reçoit d'Arduino le short int : " << piReceive.dataRec.shortintard <<" \n";
        cout << "Pi reçoit d'Arduino le char : " << piReceive.dataRec.charard <<" \n";       
       
        cout << "Taille sizeof piReceive.dataReceive : " << sizeof(piReceive.dataRec) << " octets/bytes. \n";
        cout << "\n";
        usleep(100000); //usleep est en ms  100000 pause pour 100 milliSeconds
    }

    return 0;
}

Arduino envoit : 

//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM{

  //Structure pour l'émission
  struct SEN
  {
    //taille de notre structure 11 bytes
    long ardlong ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float ardfloat;     //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int ardint;         //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte ardchar;       //1 octet/bytes (8 bits)  : -128 / +127
   
  }dataSen;

  //Structure pour la récepetion
  struct REC
  {
    //taille de notre structure 12 bytes
    long intform ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float floatform ;   //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int shortintform ;  //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte charform ;     //1 octet/bytes (8 bits)  : -128 / +127
    byte charform2 ;    //1 octet/bytes (8 bits)  : -128 / +127    
   
  }dataRec;

  //L'envoie et la réception sont dans des tableaux
  //(sizeof) permet de récupérer la taille en byte de nos structures
  unsigned char dataSend[sizeof dataSen];  
  unsigned char dataRece[sizeof dataRec]; 
 
}ardSend, ardRec;


void setup(){
  Serial.begin (115200);
 
  //Initisalisation de notre structure dataSen
  ardSend.dataSen.ardlong = 1234567891;
  ardSend.dataSen.ardfloat = 128.354;
  ardSend.dataSen.ardint = 16569;
  ardSend.dataSen.ardchar = 120;
 
}

void loop() {

  //Envoie un tableau de données dataSend au format unsigned char dans le buffer à la pi
  Serial.write (ardSend.dataSend, sizeof ardSend.dataSend);
 
  delay(100);
}

Pi reçoit :

-----
Raspberry connecté :
-----
-----
Pi reçoit d'Arduino : 7 bytes.
Pi reçoit d'Arduino le short int : 1124096672
Pi reçoit d'Arduino le float : 1.10435e-38
Pi reçoit d'Arduino le short int : 0
Pi reçoit d'Arduino le char :
Taille sizeof piReceive.dataReceive : 12 octets/bytes.

Pour l'envoi le Gcom.cpp ne change pas, vous retrouverez les valeurs initialisés dans le code :

//initisialisation de notre structure pour l'émission - dataSen
piSend.dataSen.intform = 123;
piSend.dataSen.floatform = 3.14;
piSend.dataSen.shortintform = 15210;
piSend.dataSen.charform = 70;       //Code ascii 70 vaut F
piSend.dataSen.charform2 = 73;      //Code ascii 73 vaut I

Arduino reçoit :

//Union pour envoyer nos types struct dans un tableau unsigned char
union COMM{

  //Structure pour l'émission
  struct SEN
  {
    //taille de notre structure 11 bytes
    long ardlong ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float ardfloat;     //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int ardint;         //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte ardchar;       //1 octet/bytes (8 bits)  : -128 / +127
   
  }dataSen;

  //Structure pour la récepetion
  struct REC
  {
    //taille de notre structure 12 bytes
    long intform ;      //4 octet/bytes (32 bits) : -2 147 483 648 / +2 147 483 647
    float floatform ;   //4 octet/bytes (32 bits) : -3.4028235E+38 / +3.4028235E+38
    int shortintform ;  //2 octet/bytes (16 bits) : -32 768 / +32 767
    byte charform ;     //1 octet/bytes (8 bits)  : -128 / +127
    byte charform2 ;    //1 octet/bytes (8 bits)  : -128 / +127    
   
  }dataRec;

  //L'envoie et la réception sont dans des tableaux
  //(sizeof) permet de récupérer la taille en byte de nos structures
  unsigned char dataSend[sizeof dataSen];  
  unsigned char dataRece[sizeof dataRec]; 
 
}ardSend, ardRec;

void setup(){
  Serial.begin (115200);
 
  //Initisalisation de notre structure dataSen
  ardSend.dataSen.ardlong = 1234567891;
  ardSend.dataSen.ardfloat = 128.354;
  ardSend.dataSen.ardint = 16569;
  ardSend.dataSen.ardchar = 120;
 
}

void loop() {
 
  //Récupére un tableau de données de la pi dans le buffer que l'on initialise dans dataRec
  while (Serial.available() > 0) { //if any data available

    Serial.readBytes (ardRec.dataRece, sizeof ardRec.dataRec);

    Serial.println ("Arduino reçoit Pi ");
    Serial.print ("Intform : ");
    Serial.println (ardRec.dataRec.intform);
    Serial.print ("Floatform : ");
    Serial.println (ardRec.dataRec.floatform);
    Serial.print ("Shortintform : ");
    Serial.println (ardRec.dataRec.shortintform);
    Serial.print ("Charform : ");
    Serial.println (ardRec.dataRec.charform);
    Serial.print ("Charform2 : ");
    Serial.println (ardRec.dataRec.charform2);
    Serial.print ("-----");
   
  }

  delay(100);
}

Arduino reçoit (console) :

-----Arduino reçoit Pi
Intform : 123
Floatform : 3.14
Shortintform : 15210
Charform : 70
Charform2 : 73

 

 

alors attendre avec millis : 

 

uint32_t refTime = millis();
uint16_t waitingTime = 10000;  // 10 secondes

// début de l'attente : 
while((millis()-refTime)<waitingTime){
//Attendre
}

//Fin de l'attente

pour ce qui est de la case mémoire oui perso c'est le genre de truc que je fais mais il y a un désavantage avec ce que je fais ... Je suis contrain d'avoir les même types pour toutes mes variables...  
 

Cool merci pour millis(), j'avais fais un truc du genre mais sans succès me suis planté quelque part

 

"pour ce qui est de la case mémoire oui perso c'est le genre de truc que je fais mais il y a un désavantage avec ce que je fais ... Je suis contrain d'avoir les même types pour toutes mes variables..."

 

 

Ben si je comprend bien, ma structure à l'envoie comportant un int, char, float, arduino en réception devra avoir les mêmes ??
C'est ce que je fais déjà, il y a mieux j'imagine, mais quoi ??
 

Je trouvais la solution de récupérer l'adresse mémoire sympa et d'en récupérer sont contenu sur arduino, du moins l'adresse est égal à la structure correspondante sur arduino.

Il y a énormément de moyen différent de faire ... 
Je ne les connais pas tous et ce que moi je fais n'est peut être pas optimal . 

En gros je cré un tableau côté arduino, et je cré un tableau côté raspberry pi. 

Et quand l'un demande des information à l'autre elle envoi la case du tableau souhaité et le nombre n de case souhaité après. 
La réponse sera alors les n cases demandées.

Si d'autres ont des idées, je suis curieux de voir de quelles autres façons peut on procéder.

 

En fait je fais comme toi apparemment, ma structure se retrouve dans un tableau de l'union et est envoyé dans le buff, arduino lui à un tableau (unon et structure) de réception correspondant au type prés de celui de Pi.

 

Ce qu'il va falloir que je test c'est que le tableau pi de telle adresse est envoyé, et qu'arduino reçoit cette adresse et l'attribue au tableau correspondant, ça peut être une idée, non ?

 

Comme ça, chaque adresse qui circule dans le buffer se voient attribuer une réception automatiquement.

(...)
 - Je demande aux maîtres Jedi du C++, là, je peux attaquer maintenant les classes et fonctions, ou y a t'il quelque chose de mieux pour gérer tous ça ?

Penses-tu que tu gagneras quelque chose à organiser ton code avec des classes et des méthodes, ou un ensemble de fonctions ? Si oui, lance-toi. Si non, garde ton code tel qu'il te convient, petit Padawan.

(...)
- Est ce que je peux utiliser une adresse mémoire de Pi qu'Arduino puisse récupérer ??
Genre j'ai un pointeur sur un tableau qui doit passer par le buffer, ce tableau est donc une adresse mémoire, et dire à arduino qu'il récupère ce que contient l'adresse mémoire en question ?
Cela pourrait peut être m'éviter les embrouilles sur le flux, non ??

Soit j'ai pas compris la question, soit j'ai failli hurler !
En admettant que j'ai hurlé : imagine que Arduino et Pi sont deux boîtes noires. Dans ces boîtes, tu as un trou pour mettre un tube et échanger des infos. La manière dont sont gérées les infos dans chaque boîte est différente et inconnue de tout ce qui est à l'extérieur de la boîte.
Dans une des boîtes, tu as une boîte compartimentée qui est ta mémoire, et des pointeurs qui te disent dans quel(s) compartiment(s) chercher tes infos.
Si tu envoies dans le tube tes infos, l'autre boîte sait quoi en faire (elle suit le protocole de communication et la structure des messages d'info pour les interpréter). Mais si tu envoies un pointeur, tu envoies une adresse qui ne représente rien pour la seconde boîte.
Si elle fonctionne de la même manière, elle va éventuellement tenter de lire dans ses propres compartiments (et qui sait ce qu'elle va lire). Si elle fonctionne de manière différente, elle ne sait pas quoi faire de cette adresse.
En gros, toute donnée que tu veux faire transiter doit être placée dans le tube par la boîte qui y a accès.
Mais j'ai peut-être mal compris

Ouais t'a pas compris ^^, je me doute bien que je ne peux pas me servir du pointeur de pi et être appelé par arduino

 

Je recommence, en fait j'ai mes deux boites noir et mon tuyau pour le flux, on est d'accord que les infos qui transit dans un sens comme dans l'autre peuvent se mélanger, genre j'envoie et reçois de pi et j'envoie et reçois d'arduino, donc pas très bon je trouve. (après je ne suis qu'un Padawan, mon raisonnement n'est peut être pas bon), et donc.

 

Dans la boite noir PI (je fais simple) je créer un pointeur pour un tableau (%02x on va dire que c'est l'adresse mémoire), donc, c'est adresse comporte bien mon tableau et tous se qui va dedans, maintenant je veux juste faire transiter cette adresse, l'info et donc confiner et circule dans le tuyau, ensuite ARDUINO lui à aussi un pointeur vers une case en mémoire que l'on va nommer volontairement du même nom avec le même tableau et les infos qui vont bien.

 

En gros, j'ai un tableau sur PI qui se nomme TABSERVO (adresse mémoire %02x), qui circule dans le tuyau pour atteindre une case en mémoire avec un tableau identique et du même nom sur ARDUINO, ce qui fait, que l'info TABSERVO qui circule ira toujours au même endroit sur ARDUINO, je pense à ça pour éviter le mélange d'infos dans le flux.

Et pareil dans l'autre sens avec les capteurs par exemple, j'envoie un tableau avec toutes les données des capteurs, qui une fois arriver sur PI seront attribuées directement aux cases mémoires prévu pour.

Je parlais d'adresse mémoire c'était juste pour éviter de créer une variable de plus pour donner un nom au tableau, car un ça va, plusieurs pour les dégâts lol, non mais de la mémoire prise en plus et éviter le mélange dans le flux.

 

PS : j'espère être clair, car là je ne connais pas le jargon pour la suite des événements ^^ lol

Bien entendu il doit bien y avoir une meilleur solution, j'y réfléchis, R1D1 si tu as de meilleurs façons de faire je suis preneur

Bon, bon, bon, avez vous une idée pour envoyer et recevoir en même temps, j'ai beau chercher...

 

J'explique, j'arrive donc à, pi envoie à arduino nickel (faut peaufiner certaines choses), mais en même temps j'aimerais que pi reçoit arduino.
Le truc, c'est que ça ne veut pas, pourtant lorsque pi n'envoie rien, arduino envoie très bien à pi.

 

En gros comment distinguer les deux flux si je puis dire, émission, réception.

 

Données (exemple infos des servos moteurs) : Pi ---> Arduino
Données (exemple tous les capteurs arduino) : Pi <--- Arduino

Il n'y a pas besoin de distinguer les deux flux puisqu'ils passent sur deux fils différents ... 
Je pense que j'ai pas compris ta question perso ...

Ok, Tx et Rx, si si tu as bien compris, mais le hic si j'envoie pi vers arduino ça reçoit et que arduino envoie vers pi perso moi ça passe pas.

 

Si je fais pi vers arduino seulement ça passe.

Si je fais arduino vers pi seulement ça passe.

 

Les deux en même temps ça passe pas.

 

Je dois surement faire une boulette quelque part, ou j'ai oublié un truc, j'ai bien essayé de vider le buffer entre l'envoie de pi et ça réception, mais il n'y a rien de bien folichon, je recommencerai sur cette piste.

Qu'est ce qui te fait dire que ça marche pas ?

Où est le code qui va avec ce que tu dis ? Et comme le dit Path : qu'est ce que tu observes en testant ton code qui te dit que ça marche pas?

Ben tous simplement le résultat obtenue, je ne reçois pas les bonnes valeurs de la part d'arduino lorsque j'envoie en même temps avec la pi.

 

Par contre il y a un truc que je n'ai pas testé, j'essaye ça ce tantôt, et si ça passe pas, je posterai.

Quel bordel, se prendre autant la tête, bon je crois que j'ai trouvé, dans arduino vu que j'utilisais pas mal serial.print pour voir ce qu'il se passe dans le moniteur série et bien ça me renvoyé des infos sur le flux, maintenant que j'ai viré tous les serial.print, pi reçoit bien, en revanche je n'ai aucune idée si arduino reçoit toujours aussi bien j'ai pas de visuel lol