Aller au contenu


Photo
- - - - -

Gcom communication Pi Arduino.


95 réponses à ce sujet

#1 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 02 février 2018 - 02:21

Bonjour les Maker's, je vois que vous vous ennuyez alors je déboule ^^

 

Pour ceux qui ont suivi, ces derniers temps et avec l'aide de certains membres du forum on a pu établir une communication entre la pi et arduino avec la librairie RS232 en passant par Tx/Rx (et oui je voulais passer par l'usb mais j'obtenais pas mal de pertes de données), et donc, la communication s'effectue bien avec une chaîne de caractère.

 

J'ai donc décidé de transformer un peu tous ça en séparant le programme du main avec une class, le hic, suivant la futur programmation la pi me servira surtout pour calculer tous les algos possible et après réflexion la pi enverra (dans un premier temps) :

 

- le numéro du servo sur le driver pololu

- ça vitesse

- sont accélération 

- et ça position cible

 

De l'autre coté arduino enverra en continue les données des divers capteurs à pi, avec ces données pi calculera en retour les informations pour bouger les servos.

 

Entre les deux on y trouve donc le main avec l'appel à la classe de communication (vérification de la communication, pi envoi des données arduino, pi réceptionne des données arduino).(tous n'est pas fais, c'est dans l'idée).

 

Le hic, c'est qu'à l'envoi de pi ce sont des types int, float, et peut être char et là je suis largué car incapable comment mettre ça en place, en revanche une simple chaîne de caractère passe très bien.
Du coté arduino qui gère le driver pololu pour les servos, je pense qu'il serait préférable de gérer ça par tableau, donc, pi envoi les tableaux nécessaire au fonctionnement des servos et arduino exécute les mouvements.

 

Mike m'a donné une info en passant par structure et union http://www.robot-mak...res-par-lunion/je comprend un peu le principe mais c'est l'organisation qui me manque.

 

Voilà, j'avoue que j'ai fais un peu se post à la va vite, mais là j'ai deux de tension :/
Mais l'idée est posé.

Merci.


Modifié par Oliver17, 02 février 2018 - 02:28 .

signature_01.png -->
 
 

#2 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 190 messages
  • Gender:Male
  • Location:Cholet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 02 février 2018 - 02:33

Met un petit bout de code Pi " simple " et un petit bout de code arduino "simple " que tu as et qui marche juste avec les char, et ajoute à côté les variables int / float  que tu aimerais " envoyer en char " et je te fait une petite modification sur tes programmes pour que ça marche :) 
 


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#3 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 02 février 2018 - 02:56

Franchement je n'ai rien de bien à placer, mais je peux déjà mettre ce que j'ai...

J'ai pas trop nettoyer le code pour montrer les éventuels tests que j'ai pu faire.

 

main.cpp

#include <iostream>
//#include "rs232.h"
#include "gcom.h"
//#include <cstring>
using namespace std;

int main()
{
gcom communication;
communication.openPort(); // ça c'est bon ça fonctionne.
cout << "Envoyer un message à Arduino : \n";
//strcpy(str_send, mess);
//const char * mess;
char data;
cin >> data;

char mess[] = {"coucou ceci est un test !!! \n"}; // dans l'idée pour les tests après = c'était de récupérer char data, mais ça ne passe pas.

communication.dataSend(mess);  //dans l'idée.

communication.dataReceive(); //dans l'idée.
return 0;
}

gcom.h

#ifndef GCOM_H
#define GCOM_H
#include <iostream>
//#include "rs232.h"
//#include <cstring>

class gcom
{
    private : 
    /*
    int data;
    float data;
    char data;
    */
   
    public :

    void openPort();
    void dataSend(char *);

    //void dataSend(char * = "");
    //void dataReceive(unsigned char str_recv);
    //void dataReceive(std::string str_recv);
    void dataReceive();
};
#endif

gcom.cpp

#include <iostream>
#include "rs232.h"
#include "gcom.h"
#define BUF_SIZE 128                        // taille du buffer
#define CPORT 0                             // 0 = ttyS0
#define BDRATE 9600                         // 9600 Baudrate
//#define MODE char mode []={'8','N','1',0};  // 8 data bits, no parity, 1 stop bit
using namespace std;
//int bufSize;

char MODE []={'8','N','1',0}; // 8 data bits, no parity, 1 stop bit
char str_send[BUF_SIZE];
unsigned char str_recv[BUF_SIZE]; // recv data buffer

void gcom::openPort() //test d'ouverture du port
{
    if (RS232_OpenComport(CPORT, BDRATE, MODE))
    {
        cout <<"Connection...FAILED \n";       
    }
    else{
        cout <<"Connection...OK \n";
    }
}
void gcom::dataSend(char * data) //on envoie les données et j'ai bien l'information sur arduino
{
   
    //char str_send[BUF_SIZE];
    strcpy(str_send, data);
    RS232_cputs(CPORT, str_send); // Envoie une chaîne via le port série.
    cout <<"Envoie à Arduino : \n";
    cout << str_send << "\n";
    
}
   
void gcom::dataReceive() //on reçoit les données, en revanche là, pi ne reçoit rien.
{
    //unsigned char str_recv[BUF_SIZE]; // recv data buffer
    cout << "Arduino retourne : \n";
    int n = RS232_PollComport(CPORT, str_recv, BUF_SIZE); // Obtient des caractères du port série.
    if (n > 0)
    {
        str_recv[n] = 0; // always put a "null" at the end of a string
        cout <<"Reçu : "<< n <<" bytes. " << endl;
        cout << str_recv << endl;
    }
    //cout << str_recv <<" \n";
}

Arduino

Coter arduino il n'y a rien de plus vu que j'avance à petit pas.

void setup() {
  Serial.begin(9600);
}

void loop() {
  while (Serial.available() > 0) {

    char incomingByte = Serial.read();
    Serial.print (incomingByte);
  }
}

Bon, il faut bien entendu imaginer des données que pi calcul, envoi au main qui passe par gcom arduino reçoit bouge les servos en conséquence (oui les servos car on peut imaginer minimum 25 servos), et en même temps, arduino doit envoyer les données de tous les capteurs à pi pour que celui ci puisse effectuer les calculs.

 

 


signature_01.png -->
 
 

#4 cocothebo

cocothebo

    Habitué

  • Membres
  • PipPip
  • 280 messages
  • Gender:Male

Posté 02 février 2018 - 03:03

Salut,

 

Je dirai qu'il y a deux approches assez différentes:

 

la version "facile à comprendre" mais peu optimisée qui consiste à serialiser à la main les données, c'est facile, tu as une valeur mettons un float de 12.1258 (qu tu peux arrondir/tronquer au nombre de décimal voulu bien sur), tu envoie sur le port série les caractères qui correspondent soit la string "12.1258" et de l'autre côté tu reconstruis la valeur en faisan l'opération inverse.

Normalement si tu envoies un float par un float, tu peux utiliser ftoa() et atof() pour faire les conversions.

Si tu veux envoyer plusieurs valuer d'un coup genre "12,5:toto:6:..." et que la structure est toujours composée des mêmes types dans le même ordre un strtok() devrait permettre de découper la chaine en utilisant le ":" comme séparateur, puis les conversions morceau par morceau.

 

 

La version plus "propre" portable et sans se fatiguer à parser des chaines de caractères est bien l'utilisation d'une union, qi au final n'est qune variable surlaquelle on donne plusieurs types, on alloue un espace mémoire pour le type le plus long, et après on considère cet espace mémoire suivant le type du paramètre de l'union. Il faut lire le tuto de Mike il est je trouve très clair.

Mais si on reprend l'exemple pour la version du dessus, dans le cas juste d'un float tu déclares qqc comme:

union myUnion
{
  float myFloat;
  uint8_t mySerial[sizeof(float)]; 
} myData;

Quand tu dois utiliser la valeur tu recuperes le "myFloat", quand tu veux l'envoyer sur le port série tu utilises le "mySerial", du style:

myData.myFloat = lireCapteurX()

...

Serial.write(myData.mySerial[i])

Bien sur le le write doit parcourir le tableau entier.

 

 

 

Pour le deuxième exemple de transfert de valeurs concaténées ("12,5:toto:6:..."), il faut faire une union utilisant une structure, du genre

union myUnion
{
  struct CONCAT {
  float myFloat;
  uint8_t myString[4]; 
  uint8_t myByte; 
  } jaimelescarottes;
  uint8_t mySerial[sizeof(CONCAT)]; 
} myData;

Idem quand tu dois utiliser la valeur tu recuperes le "myFloat" ou "myString" etc de la structure "jaimelescarottes", quand tu veux l'envoyer sur le port série tu utilises le "mySerial", du genre

myData.jaimelescarottes.myFloat = lireCapteurX()

...

Serial.write(myData.mySerial[i])

Et bien sur dans les deux cas en réception tu fais l'inverse du genre

myData.mySerial[i] = Serial.read()  (attention tjs une boucle à mettre ici)


valeurCapteurX = myData.jaimelescarottes.myFloat;

Edit: Arf réponse trop longue j'ai été précédé ;)


Modifié par cocothebo, 02 février 2018 - 03:05 .


#5 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 190 messages
  • Gender:Male
  • Location:Cholet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 02 février 2018 - 03:12

Bon finalement avec les précisions de cocothebo je te laisse d'abord essayer de faire la modif toi Oliver ;) 

Je trouve qu'il a bien illustrer mon "tuto" :) ( qui au passage manque d'exemple pour être un vrai tuto je pense x) )  


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#6 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 02 février 2018 - 03:19

'tain, déjà le tuto de Mike je l'ai d'ouvert en permanence ces derniers temps ^^

'tain, le plus dramatique c'est que je crois comprendre mais c'est la mise en place qui me freine (je crois que je me met des bâtons dans les roues tous seul).

'tain, je crois que je vais allez dormir un peu, je dors devant l'ordi, mais là, je ne sais pas pourquoi mais j'aime les carottes :)

 

PS : du coup (avec ma tronche d'endormi), quelle est la meilleur façon de procéder, ou plutôt la quelle choisiriez vous ? 

Comme ça, autant faire les choses propre même si c'est un peu plus chiant à mettre en place.


signature_01.png -->
 
 

#7 cocothebo

cocothebo

    Habitué

  • Membres
  • PipPip
  • 280 messages
  • Gender:Male

Posté 02 février 2018 - 03:32

Franchement la solution à base d'oignons union reste quand même la plus "élégante" et permet aussi d'optimiser les conversions (yen a pas à faire en fait, on écrit juste en mémoire et paf ça marche) et l'espace mémoire, ainsi que le volume de donnée transmises.

 

C'est peut être un peu moins compréhensible quand on ne connait pas, mais ça te permettra un code plus compact et au final plus simple (pas de risque d'ereur de conversion, d'utilisation de fonctions C qui ne marchent pas tjs pareil si la libC utilisée n'est pas la même).

 

Je trouve que le seul truc sympa d'envoyer le "12,5:toto:6:..." c'est que tu peux voir si un truc cloche avec un sniff série. Dans le cas de l'union+structure faut reconstruire.

 

 

Pour le volume de donnée c'est assez efficace, un exemple (extrême certes): l'envoie du flotant 1,1234567 (de mémoire c'est le nombre de décimales max pour les float sur arduino):

  • solution chaine de caractère: "1,1234567" soit 9 octets (1 par digit)
  • solution union 4 octets (la taille mémoire du float)

On voit que dans ce cas "extrême" on gagne plus de 50% de transmission.

 

Pour la version style "12,5:toto:6:..." on gagne en plus sur le fait qu'on a pas besoin de transmettre de délimiteur entre les types.



#8 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 03 février 2018 - 10:24

Coucou les maker's, auriez vous un ou plusieurs petit exercices à me faire faire sur le sujet comportant union et structure, mais un p'tit truc hein, pas le truc de malade ;)

 

Car je mélange pas mal de chose...

 

Merci.


signature_01.png -->
 
 

#9 Path

Path

    Made By Humans

  • Modérateur
  • PipPipPipPipPip
  • 2 255 messages
  • Gender:Male
  • Location:Paris

Posté 03 février 2018 - 12:17

Tu peux construire une union, la remplir avec des données. Tu sérialise dans un tableau doctets.
Tu utilise ce tableau comme si cétait ton RX et tu le lis avec l'union (pas octet par octet).

Podcast Made By Humans

Je cherche des volontaires de tous niveaux pour nos petites conversations entre hobbyistes.

Accès aux salles secrètes

 


#10 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 190 messages
  • Gender:Male
  • Location:Cholet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 03 février 2018 - 04:31

Je repasse plus tard ( genre demain ) pour mettre un code de communication entre deux arduino si personne en poste un entre temps ;)  


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#11 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 03 février 2018 - 07:33

Bon j'ai essayé ça, et vous vous doutez bien que ça foire ^^

 

main.cpp  

Je post le main, mais mes premières erreurs sont dans le gcom.cpp.

#include <iostream>
#include <stdint.h>
#include "rs232.h"
#include "gcom.h"

using namespace std;

union comm
{
  struct CONCAT
  {
    uint8_t servo;
    uint8_t speed;
    int16_t acceleration;
    int16_t target;
    //float e;

  } data;

  uint16_t piSerial[sizeof(CONCAT)];

} piData;


int main()
{
gcom communication;
communication.openPort();

piData.data.servo = 73;

for(int8_t i=0; i<piData.piSerial; i++)
{
communication.dataSend(piData.piSerial[i]); 
}


//communication.dataReceive();


return 0;
}

gcom.h

#ifndef GCOM_H //DEF_GCOM
#define GCOM_H //DEF_GCOM

#include <iostream>
#include <stdint.h>

class gcom
{
    private :
    //char mess;
   
    public :

    void openPort();
    void dataSend(uint16_t *);

};
#endif

gcom.cpp

#include <iostream>
#include <stdint.h>
#include "rs232.h"
#include "gcom.h"

#define BUF_SIZE 128                        // taille du buffer
#define CPORT 0                             // 0 = ttyS0
#define BDRATE 9600                         // 9600 Baudrate

using namespace std;

char MODE []={'8','N','1',0}; // 8 data bits, no parity, 1 stop bit
char str_send[BUF_SIZE];
unsigned char str_recv[BUF_SIZE]; // recv data buffer

void gcom::openPort() //test d'ouverture du port
{
    if (RS232_OpenComport(CPORT, BDRATE, MODE))
    {
        cout <<"Connection...FAILED \n";  
    }
    else{
        cout <<"Connection...OK \n";
    }
}

void gcom::dataSend(uint16_t * data) //on envoie les données
{
    //char str_send[BUF_SIZE];
    //strcpy(str_send, data);
    //RS232_cputs(CPORT, str_send); // Envoie une chaîne via le port série.
    RS232_cputs(CPORT, data); // Envoie une chaîne via le port série.
    cout <<"Envoie à Arduino : \n";
    cout << data << "\n";

}

et l'erreur lorsque j'essaye de compiler gcom.cpp, du moins essayer d'en faire un .o

g++ -c gcom.cpp

gcom.cpp: In member function ‘void gcom::dataSend(uint16_t*)’:
gcom.cpp:40:28: error: cannot convert ‘uint16_t* {aka short unsigned int*}’ to ‘const char*’ for argument ‘2’ to ‘void RS232_cputs(int, const char*)’
     RS232_cputs(CPORT, data); // Envoie une chaîne via le port série.

signature_01.png -->
 
 

#12 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 190 messages
  • Gender:Male
  • Location:Cholet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 03 février 2018 - 08:16

Hum ... Il faut que dans ton union tu ais un type de variable qui convient au type demandé par le constructeur de ta fonction. 

 

et ensuite tu utilise la forme requise pour envoyer les données . 

Exemple : 

union DATA {
   uint8_t uint8form[4 ]
   char   charform[4] 
   float  floafform; 

 

}data;

 

 

si tu as

une méthode qui a besoin d'un char genre  : send ( char )

 

tu fais 

 

send(data.charform[i]);  ça enverra le char i 

Et pour envoyer tous les char tu boucles sur i de 0 à 3. 


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#13 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 04 février 2018 - 09:33

Hum, pas bien compris, vais relire plusieurs fois, me réveil (smiley qui fait ZZZzzzzz) ^^


signature_01.png -->
 
 

#14 cocothebo

cocothebo

    Habitué

  • Membres
  • PipPip
  • 280 messages
  • Gender:Male

Posté 05 février 2018 - 01:53

Salut,

 

D'après le message d'erreur on dirait que la fonction RS232_cputs prend un char* (équivalent à un uint8_t*) en entrée.

Toi tu lui donnes un uint16_t* => le compilo est pas content.

 

Donc a priori (je connais pas  RS232_cputs), il faut que tu lui passes un char*, et donc dans ton union, il faut que ce soit aussi un uint8_t le tableau utilisé pour la sérialisation.

 

 

 

En plus dans ton code, tu définis:

union comm
{
  struct CONCAT
  {
    uint8_t servo;
    uint8_t speed;
    int16_t acceleration;
    int16_t target;
    //float e;

  } data;

  uint16_t piSerial[sizeof(CONCAT)];

} piData;

avec piSerial qui est un tableau de "double octet" (uint16_t) de taille de la structure, taille qui est en octets elle. Bref tu alloues donc un tableau qui fait le double de celui de la structure, ce tableau a bien autant de "cases" que la taille de CONCAT, mais chaque case fait 2 octets.



#15 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 05 février 2018 - 05:28

Bon, bon, bon, je m'y remet juste j'avoue, et déjà ça me fatigue, je pige pas tout, je pensais avoir bien calculer  ce qui devait passer, preuve que je n'ai rien compris :'(

Snif...

 

void RS232_cputs(int comport_number, const char *text)

  Sends a string via the serial port. String must be null-terminated.

 

Toutes les fonctions sont marquées sur cette page pour la lib rs232.

 

https://www.teuniz.net/RS-232/

 

Effectivement ça sert à envoyer une chaîne de caractères, et c'est bien là mon problème car ça n'envoi que ça, d'ou la solution de Mike en essayant avec union et structure pour envoyer autre que des strings. :P

 

Ou alors se servir d'autre chose que cette librairie ??????????

Ou modifier la librairie pour quelle accepte autre que le type char ???????

 

Perso, je nage et rame à la fois, j'ai nettement l'impression de perdre mon temps avec ça, le noob que je suis (ou l'envie de baisser les bras), me dit que ce n'est pas possible en fait :/
Sinon ce serait déjà fait.

 

PS : et svp ne me parler pas de python.


signature_01.png -->
 
 

#16 Mike118

Mike118

    Staff Robot Maker

  • Administrateur
  • PipPipPipPipPip
  • 7 190 messages
  • Gender:Male
  • Location:Cholet
  • Interests:Robotique, Entrepreneuriat, Innovation, Programmation, Résolution de problème, Recherche de solutions, Mécanique, Electronique, Créer, Concevoir

Posté 05 février 2018 - 07:50

Bon oublions deux minutes la notion de structure pour se concentrer sur la notion d'union. 

 

Voilà l'exemple le plus simple que je puisse faire je pense pour illustrer le morphisme de type par l'union:
 

union FLOATDATA {
 
float floatform;    // un float a une taille de 4 Bytes
char charform[4];   // un tableau de 4 char , même  taille 4 Bytes 

} ;

FLOATDATA monFloatEnvoi; 
FLOATDATA monFloatRecu; 


monFloatEnvoi.floatform = 127,504 ;  // On utilise la forme float pour enregistrer directement le float. 


// Soit la fonction send(char) qui envoit char par char 

for (uint8_t i = 0; i<4; i++ ) {
send( monFloatEnvoi.charform[i] ) ; 
}

// Soit la fonction de reception read() que retourne le char lu 

for( uint8_t i = 0; i<4; i++){
 monFloatRecu.charform[i]= read();
}

//Soit la fonction d'affichage printFloat qui affiche un float et qui prend un float en paramètreon fera : 
printFloat( monFloatRecu.floatform ) ; 



Est ce plus clair ? 


Si mon commentaire vous a plus laissez nous un avis  !  :thank_you:

Nouveau sur Robot Maker ? 

Jetez un oeil aux blogs, aux tutoriels, aux ouvrages, au robotscope  aux articles,  à la boutique  et aux différents services disponible !

 

Les réalisations de Mike118  

 

 

 


#17 R1D1

R1D1

    Modérateur et Membre passionné

  • Modérateur
  • PipPipPipPipPip
  • 1 057 messages
  • Gender:Male
  • Location:Autriche

Posté 05 février 2018 - 08:10

Bon.
Imagine un système à tube pneumatique comme dans l'ancien temps :


Le système fonctionne avec des capsules propulsées par l'air sous pression. Tout ce que tu veux faire transiter par le réseau de tubes doit être dans une capsule. Que ce soit une lettre, un objet, etc.
La lib RS232, c'est un système à tubes pneumatiques tout prêt. La seule chose que tu peux mettre dedans, ce sont des capsules (des char). Si tu essaies de mettre autre chose (genre ta lettre directement), ça risque de ne pas marcher comme tu veux.
Ton problème, ça n'est pas d'envoyer des float, c'est de te demander comment faire rentrer tes float dans des char. Et comment ouvrir de l'autre côté des capsules (interpréter tes char) pour récupérer ta lettre (récupérer le flottant).
Déjà, il faut comprendre qu'une capsule (un char), ça n'est pas gros (1 octet). Si tu veux envoyer une longue lettre (un float, en général 4 octets), il va falloir la découper en morceaux qui rentrent dans des capsules différentes. Si tu ouvres une capsule qui ne contient qu'une partie de l'info, tu ne vas pas comprendre l'information globale.
Il faut donc définir une règle pour interpréter les char qui arrivent sur le réseau. Exemple : si le premier char que je reçois est un f, je dois agglomérer les 4 prochains et les interpréter comme un float.
L'union est une réponse à ce problème, parce que si tu as e.g. un champ float et un champ char, à priori tu as une conversion "gratuite" (voir https://openclassroo...s#/id/r-1101784) dans le sens char->float et vice-versa (par contre, faire une conversion entre d'autres types que char et un type standard me semble une mauvaise idée ; après je ne maîtrise pas plus que ça les unions).

C'est plus clair ?

(...)
PS : et svp ne me parler pas de python.



:D
R1D1 - Calculo Sed Ergo Sum -- en ce moment, Projet Ballista
Avatar tiré du site bottlebot
Donnez votre avis sur la restructuration des catégories du forum : http://www.robot-mak...ation-du-forum/

#18 Path

Path

    Made By Humans

  • Modérateur
  • PipPipPipPipPip
  • 2 255 messages
  • Gender:Male
  • Location:Paris

Posté 05 février 2018 - 08:30

Perso, je nage et rame à la fois, j'ai nettement l'impression de perdre mon temps avec ça, le noob que je suis (ou l'envie de baisser les bras), me dit que ce n'est pas possible en fait :/

Sinon ce serait déjà fait.

 

PS : et svp ne me parler pas de python.

Grrr. Tu sais ce que j'en pense.

 

 


Podcast Made By Humans

Je cherche des volontaires de tous niveaux pour nos petites conversations entre hobbyistes.

Accès aux salles secrètes

 


#19 Oracid

Oracid

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 3 695 messages
  • Gender:Male

Posté 05 février 2018 - 09:12

C'est plus clair ?

Oh, oui !
Ma chaine vidéo YouTube : https://www.youtube....wMz-IzZqyvqEUek

#20 Oliver17

Oliver17

    Pilier du forum

  • Modérateur
  • PipPipPipPipPip
  • 2 214 messages
  • Gender:Male
  • Interests:Glenn

Posté 06 février 2018 - 05:26

Oh, oui !

 

Oh l'autre, comment il frime ^^
 

Bon sinon j'ai fais des ptits tests, juste avec l'union, ça compile bien, mais lorsque je lance l'exe j'ai se message après le connexion à l'arduino.

./main
Connection...OK
Erreur de segmentation

Je ne met pas le code exprès, j'aimerais juste des informations sur l'erreur de segmentation, j'ai cherché sur google mais on trouve de tous et de rien de précis sur le sujet (ou j'ai mal cherché). 

 

Merci ^^


signature_01.png -->
 
 



Répondre à ce sujet



  


0 utilisateur(s) li(sen)t ce sujet

0 members, 0 guests, 0 anonymous users