95 réponses à ce sujet

[R1D1]

T'as essayé le premier résultat : https://fr.wikipedia...de_segmentation?

En plus, t'as des beaux exemples en C/C++ avec des pointeurs, même !

(plus sérieusement, la page de wiki explique vraiment clairement ce qu'est une erreur de segmentation).

[Oliver17]

Ben je n'avais pas le wiki en résultat.

M'enfin ^^ je vais y jeter un oeil .

 

A tous les coups c'est à cause de mon pointeur

(ou pas).

Modifié par Oliver17, 06 février 2018 - 06:50 .

[Path]

Peut-être tu as mal initialisé un pointeur.

[Oliver17]

Coucou les maker's, du coup Mike a prit de son temps pour m'aider et m'expliquer certaines choses, dont mieux s'organiser pour travailler sur du code.

 

Donc je post le test du Gcom avec union, d'autres tests sont avenir :

#include <iostream> // Permet d'utiliser In et Out du moniteut série
#include "rs232.h"  // Librairie de communication RS232
#include <stdint.h> // Nécessaire pour l'utilisation du standard int : uint8_t
#define BUF_SIZE 5  // Tableau à 5 élèments pour 4 bytes de données.

using namespace std;

union COMM
{
    float floatform;
    char dataSend[BUF_SIZE];
    unsigned char dataReceive[BUF_SIZE];
};

COMM piSend;
COMM piReceive;

int main()
{
    piSend.floatform = 56.41;

    int cport_nr(0);                // 0 = ttyS0
    int bdrate(9600);               // Baud
    char mode []={'8','N','1',0};   // 8 data bits, no parity, 1 stop bit

    if (RS232_OpenComport(cport_nr, bdrate, mode)) // Test et ouvre le port.
    {
        cout <<"Ne peut pas ouvrir le port com. \n";
        return 0;
    }

    cout << "Raspberry connecté : \n" ;

    while(1)
    {
        RS232_cputs(cport_nr, piSend.dataSend); // Envoie une chaîne via le port série.

        cout <<"Pi envoie le float : " << piSend.floatform << "\n";
        cout <<"Pi envoie à Arduino le char : " << piSend.dataSend << "\n";
        sleep(1);

        int n = RS232_PollComport(cport_nr, piReceive.dataReceive, BUF_SIZE); // Obtient des caractères du port série.
       
        if (n > 0)
        {
            piReceive.dataReceive[n] = 0;
            cout <<"Pi reçoit d'Arduino : "<< n <<" bytes. \n";
            cout <<"Pi reçoit d'Arduino le char : " << piReceive.dataReceive << "\n";
        }

        cout << "Pi reçoit d'Arduino le float : " << piReceive.floatform <<" \n";
        cout << "\n";
    }

    return 0;
}

Vous trouverez en pièce jointe le pack complet avec le fichier .ino pour Arduino.

 

Encore merci Mike pour cette leçon.

Fichier(s) joint(s)

•  Gcom.zip   6,69 Ko   41 téléchargement(s)

[R1D1]

Coucou les maker's, du coup Mike a prit de son temps pour m'aider et m'expliquer certaines choses, dont mieux s'organiser pour travailler sur du code.
 
(...)
Vous trouverez en pièce jointe le pack complet avec le fichier .ino pour Arduino.
 
Encore merci Mike pour cette leçon.

Ça marche ?

[Mike118]

Ça marche ?

 

Bah oui non mais ! =)

[Oliver17]

OOUIII ça fonctionne, mais j'aurais mis un moment avant de trouver ^^

[Oliver17]

Et ben voilà, j'ai tous cassé ^^

#include <iostream> // Permet d'utiliser In et Out du moniteut série
#include "rs232.h"  // Librairie de communication RS232
#include <stdint.h> // Nécessaire pour l'utilisation du standard int : uint8_t
//#include <string>  // Pour strtok, permet de découper une chaine
#define BUF_SIZE 128  // Taille du buffer en bytes + le 0 de fin.

using namespace std;

union COMM
{
    struct CONCAT
    {
        char charform;              //8 bits - 1 octets/bytes
        short int shortintform;     //16 bits - 2 octets/bytes
        //int intform;                //16/32 bits - 2/4 octets/bytes
        float floatform;            //32 bits - 4 octets/bytes
        //double floatform;           //64 bits - 8 octets/bytes
        //char charform; 
        //char dataSendS[BUF_SIZE];
        //unsigned char dataReceiveS[BUF_SIZE];
        //char dataSendS[sizeof (CONCAT)];
        //unsigned char dataReceiveS[sizeof (CONCAT)];
    } data;

    //char dataSend[BUF_SIZE];
    //unsigned char dataReceive[BUF_SIZE];
    char dataSend[sizeof (data)+1];
    unsigned char dataReceive[sizeof (data)+1];
};

COMM piSend;
COMM piReceive;

int main()
{

    piSend.data.charform = 70;
    piSend.data.shortintform = 11070;
    piSend.data.floatform = 56.41;
   
    cout << "Taille sizeof char : " << sizeof(piSend.data.charform) << " octets/bytes. \n";
    cout << "Taille sizeof short int : " << sizeof(piSend.data.shortintform) << " octets/bytes. \n";
    //cout << "Taille sizeof int : " << sizeof(piSend.data.intform) << " octets/bytes. \n";
    cout << "Taille sizeof float : " << sizeof(piSend.data.floatform) << " octets/bytes. \n";
    cout << "Taille sizeof char dataSend buffer : " << sizeof(piSend.dataSend) << " octets/bytes. \n";
    //cout << "Taille float : " << sizeof(floatform) << "\n";

    int cport_nr(0);                // 0 = ttyS0
    int bdrate(9600);               // Baud
    char mode []={'8','N','1',0};   // 8 data bits, no parity, 1 stop bit

    if (RS232_OpenComport(cport_nr, bdrate, mode)) // Test et ouvre le port
    {
        cout <<"Ne peut pas ouvrir le port com. \n";
        return 0;
    }
    cout << "Raspberry connecté : \n";

    while(1)
    {  

        RS232_cputs(cport_nr, piSend.dataSend); // Envoie une chaîne via le port série.

        /*int u = RS232_cputs(cport_nr, piSend.dataSend); // Envoie une chaîne via le port série.

        if (u > 0)
        {
            piSend.dataSend[u] = 0;
            cout <<"Pi envoie : "<< u <<" bytes. \n";
            cout <<"Pi envoie à Arduino le char dataReceive : " << piSend.dataSend << "\n";
        }*/
       
       
        cout <<"Pi envoie le char : " << piSend.data.charform << "\n";
        cout <<"Pi envoie le short int : " << piSend.data.shortintform << "\n";
        cout <<"Pi envoie le float : " << piSend.data.floatform << "\n";
        cout <<"Pi envoie à Arduino le char dataSend : " << piSend.dataSend << "\n";
        sleep(1);

        int n = RS232_PollComport(cport_nr, piReceive.dataReceive, BUF_SIZE); // Obtient des caractères du port série.
       
        if (n > 0)
        {
            piReceive.dataReceive[n] = 0;
            cout <<"Pi reçoit d'Arduino : "<< n <<" bytes. \n";
            cout <<"Pi reçoit d'Arduino le char dataReceive : " << piReceive.dataReceive << "\n";
        }

        cout << "Pi reçoit d'Arduino le char : " << piReceive.data.charform <<" \n";
        cout << "Pi reçoit d'Arduino le short int : " << piReceive.data.shortintform <<" \n";
        cout << "Pi reçoit d'Arduino le float : " << piReceive.data.floatform <<" \n";
       
        //cout << "Pi reçoit d'Arduino le int : " << piReceive.data.intform <<" \n";
       
        cout << "Taille sizeof char dataReceive : " << sizeof(piSend.dataReceive) << " octets/bytes. \n";
        cout << "\n";
    }

    return 0;
}

Et le retour :

Taille sizeof char : 1 octets/bytes.
Taille sizeof short int : 2 octets/bytes.
Taille sizeof float : 4 octets/bytes.
Taille sizeof char dataSend buffer : 9 octets/bytes.
Raspberry connecté :
Pi envoie le char : F
Pi envoie le short int : 11070
Pi envoie le float : 56.41
Pi envoie à Arduino le char dataSend : F
Pi reçoit d'Arduino : 1 bytes.
Pi reçoit d'Arduino le char dataReceive : F
Pi reçoit d'Arduino le char : F
Pi reçoit d'Arduino le short int : 0
Pi reçoit d'Arduino le float : 0
Taille sizeof char dataReceive : 9 octets/bytes.

Le truc, c'est qu'il n'y que le premier type de la structure qui est envoyé, si je met un autre type cela confirme ce que je dis
 

[Path]

Tu as testé n ?

[Path]

Pour résumer la discussion sur le discord,

 

n vaut 1 malgré le sleep 1

 

Selon la doc https://www.teuniz.net/RS-232/

 

La fonction de lecture n'est pas bloquante. Il faut la lire en boucle et remplir un buffer. Arrêter la boucle quand la quantité d'octets est celle voulu ou quand on a trop attendu.

 

La fonction d'écriture ne semble pas la bonne. A mon sens, il vaut mieux utiliser RS232_SendBuf que RS232_cputs.

[Mike118]

En tout cas visiblement là c'est pas un problème d'union ou de structure ( je pense que tu l'as bien fait ça ) mais un problème d'envois ou de réception ! =) 

( le seul truc qui me chagrine et c'est cette histoire de taille de ta structure, il faut que ça soit une taille fixe et bien définie mais on verra ça plus tard ^^ )

Et maintenant pour savoir si c'est un problème d'envois ou de réception, 

 

tu peux envoyer sur le serial 1 de l'arduino par exemple  et lui faire faire des retours sur le moniteur série !
Puis inversement   Envoyer la structure depuis l'arduino et vérifier =)

[Oliver17]

Plop les maker's, j'ai donc trouvé le pourquoi du comment ça merdouille dans le tuyau ^^

 

Explication : en résumé si je place dans ma structure (qui elle se trouve dans un union) et dans cette ordre (pour le test)

int a;
float b;
char c;

et que j'initialise de cette façon

a = 1234567891;
b = 53.701
c = 70;

Si je lis les valeurs les unes après les autres, ça passe, MAIS, il suffit que le nombre de bytes pour le int ne soit pas totalement rempli (ou autres type) :

a = 123;
b = 53.701
c = 70;

là ça merdouille, pourquoi, ma seule conclusion est que si le nombre de bytes n'est pas rempli sur le int qui en vaut (2 bytes pour 16 bits ou 4 bytes pour 32 bits tous dépend de la valeur entrée), et donc 123 et donc sur 1 bytes (8 bits) qui est d'ailleurs la valeur d'un char (bref), on y vient, comme j'ai que 1 bytes de remplis sur les 4 bytes pour un int, il reste donc 3 bytes vide, le hic, des que mon tableau est lu pour l'envoi de la chaîne, et bien il s'arrête à l'arrivée du premier byte vide.

Bien entendu en grugeant on place les types dans un certains ordre et ça passe, mais le problème réapparaîtra tôt ou tard, ce n'est pas donc une bonne solution.

 

En gros, la concaténation ne s'effectue pas, (normal), je cherche un truc qui me permettrait de dire que si il y a 1 bytes vide de passer au suivant et au delà de 3 bytes vide il stop sont parcours dans le tableau.

Le hic c'est que je ne veux pas que le programme prenne les 3 bytes de fin vide et les associes à la chaine, genre on reprend notre structure 

 

int = 4 bytes (sur ma pi c'est calculer au plus gros et s'adapte selon la valeur, mais garde toujours 4 bytes)

float = 4 bytes

char = 1 bytes

 

ce qui nous fait 9 bytes au total, mais si il associe les 3 bytes en fin de chaîne cela monte donc à 12 bytes et donc cela prend plus de place dans le bufer.

 

Je test la fonction strtok() que @Cocothebo a proposé plus haut, mais sans grand succès, je dois mal m'y prendre, cela m'écrit juste ce qui se trouve dans le tableau tant qu'il n'y a pas de byte de vide.

J'ai regardé getline() là j'ai encore moins de résultat, ça merdouille et j'ai l'impression que ça ne prend que le type string.

 

Références : 

http://web.maths.unsw.edu.au/~lafaye/CCM/cpp/cpptype.htm

 

@Cocothebo :

 

"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."

 

Perso je veux bien économiser 50 % de transmission, mais le hic en me servant que de l'union je ne récupère que le premier type dans le tableau, les autres types ne sont pas écrit dans le tableau.

Je continue mes tests

 

Merci.

[Mike118]

Hum c'est fâcheux ça ...

Tu as testés les différentes façon d'envoyer disponible dans ta librairie ? 

[Oliver17]

@Mike : Il y en a pas des masses, je vais retester le sendbuf voir.

 

PS : Ok compris avec l'union, c'est pas jouable 

[Path]

C'est peut-être que si tu envois une chaîne avec 0 juste après la première donnée, il pense que c'est la fin. La valeur 0, pas le caractère 0

[Oliver17]

@Path : mais la chaîne se créer (comme NULL j'ai envie de dire) et prend donc un byte pour rien.

 

Mais sinon, avec sendBuff comme avait conseillé Path, ben ça a l'air de fonctionner, il faut que je range un peu se code et que je fasse d'autres tests, en tous cas, d'après ce que je vois c'est que du bon (ne pas crier victoire trop tôt)...

 

Bon, c'est nickel, on envoie bien, on reçoit bien, juste un truc qui me chagrine coter arduino, il me renvoi la taille complète du buffer, mais ceci dis, il n'affiche bien entendu que le nombre de bytes aillant circulé.

Modifié par Oliver17, 14 février 2018 - 06:31 .

[Path]

Du coup, jai pas compris c'est tombé en marche ?

[Mike118]

Renvois tes derniers codes qu'on corrige ce dernier point qui te chagrine  

[Oliver17]

Je vais d'abord essayer de me débrouiller tout seul.

 

Demain si je peux je me remet dessus

[Oliver17]

Plop les maker's, bon j'ai trouvé, fallait que je vire le retour dans la boucle, et aussi gérer la taille du buffer automatiquement selon ce qu'il doit envoyer, car j'envoyé tout le temps 128 bytes pour 12 bytes réellement envoyé

 

Mes prochains tests : (on m'a dit étape par étape). 

 

- Récupérer toutes les valeurs et les afficher dans Arduino.

- Récupérer les valeurs char envoyé par Pi sur Arduino et les transformer en uint8_t.

 

Bref ça sent l'embrouille lol

 

Je vous places tout de même le code pour les curieux

 

 

Gcom.cpp

#include <iostream> //Permet d'utiliser In et Out du moniteut 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 COMM
{
    struct CONCAT
    {
        int intform ;           //16/32 bits - 2/4 octets/bytes
        float floatform ;       //32 bits - 4 octets/bytes
        short int shortintform ;//16 bits - 2 octets/bytes
        char charform ;         //8 bits - 1 octets/bytes
        char charform2 ;        //8 bits - 1 octets/bytes
    } data;

    //sizeof nous permets de récupérer la taille de notre structure
    unsigned char dataSend[sizeof (data)];
    unsigned char dataReceive[sizeof (data)];
};

COMM piSend;
COMM piReceive;

int BUF_SIZE = sizeof (piSend.dataSend);

int main()
{
    //Initisialisation de notre structure
    piSend.data.intform = 123;
    piSend.data.floatform = 3.14;
    piSend.data.shortintform = 15210;
    piSend.data.charform = 70;
    piSend.data.charform2 = 73;

    //On vérifie se que l'on veut envoyer
    cout << "Taille sizeof char : " << sizeof(piSend.data.charform) << " octets/bytes. \n";
    cout << "Pi envoie le char : " << piSend.data.charform << " \n";
    cout << "----- \n";
    cout << "Taille sizeof char2 : " << sizeof(piSend.data.charform2) << " octets/bytes. \n";
    cout << "Pi envoie le char2 : " << piSend.data.charform2 << " \n";
    cout << "----- \n";
    cout << "Taille sizeof short int : " << sizeof(piSend.data.shortintform) << " octets/bytes. \n";
    cout << "Pi envoie le short int : " << piSend.data.shortintform << " \n";
    cout << "----- \n"; 
    cout << "Taille sizeof float : " << sizeof(piSend.data.floatform) << " octets/bytes. \n";
    cout << "Pi envoie le float : " << piSend.data.floatform << " \n";
    cout << "----- \n";
    cout << "Taille sizeof int : " << sizeof(piSend.data.intform) << " octets/bytes. \n";
    cout << "Pi envoie le int : " << piSend.data.intform << " \n";
    cout << "----- \n";
    cout << "Taille sizeof piSend.dataSend : " << sizeof (piSend.dataSend) << " octets/bytes. \n";

    int cport_nr(0);                // 0 = ttyS0
    int bdrate(115200);             // Baud
    char mode []={'8','N','1',0};   // 8 data bits, no parity, 1 stop bit

    if (RS232_OpenComport(cport_nr, bdrate, mode)) // Test et ouvre le port
    {
        cout <<"Ne peut pas ouvrir le port com. \n";
        return 0;
    }
    cout << "----- \n";
    cout << "Raspberry connecté : \n";
    cout << "----- \n";

    while(1)
    { 
        RS232_SendBuf(cport_nr, piSend.dataSend, BUF_SIZE); //On envoit ce que contient le BUFFER
       
        //On vérifie byte par byte ce qui circule
        cout << "Pi envoie à Arduino via SendBuff - \n" ;
        for (short int i=0; i<sizeof (piSend.dataSend); i++)
        {
            cout << "- Send via SendBuff : " << piSend.dataSend[i] << "\n";

        }
        cout << "----- \n";

        sleep(1);

    }
    return 0;
}

^^