Construire une trame de données en c++

salsou34 Messages postés 9 Date d'inscription mardi 10 avril 2007 Statut Membre Dernière intervention 29 mai 2007 - 11 mai 2007 à 14:11
salsou34 Messages postés 9 Date d'inscription mardi 10 avril 2007 Statut Membre Dernière intervention 29 mai 2007 - 9 juil. 2012 à 23:12
Bonjour,

J'essai depuis plusieurs jours de créer une trame de données afin de l'envoyer sur un port serie.

Ma trame serait constitué de 45 octets;

Début de trame = 1 octet;

6 float de 4 octet = 24 octets;

et le CRC = 20 octets;

j'ai créer une structure Trame avec mes données mais le souci c'est que
ma fonction WriteCom me dit qu'elle attends un float et qu'elle ne peut
pas convertir struct to float:

error C2664: 'WriteCOM' : cannot convert parameter 2 from 'struct Trame' to 'float'.

A l'aide, merci

9 réponses

luhtor Messages postés 2023 Date d'inscription mardi 24 septembre 2002 Statut Membre Dernière intervention 28 juillet 2008 6
11 mai 2007 à 18:33
Bas mets le code en question. Car la c'est évident que t'as une erreur de type, mais dire par quoi corriger, ca va etre difficile :)
0
emmatopiak Messages postés 149 Date d'inscription mercredi 28 mars 2007 Statut Membre Dernière intervention 17 mai 2007 2
12 mai 2007 à 18:48
Salut,

Tu pourrais aussi dire quelle est la librairie que tu utilises car je trouve pas sur google ta fonction writeCom ou ses arguments..

Une autruche ne se cuit pas aux petits lardons.
0
salsou34 Messages postés 9 Date d'inscription mardi 10 avril 2007 Statut Membre Dernière intervention 29 mai 2007
14 mai 2007 à 13:25
Bonjour,
Merci les gars de vous soucier de mon probleme, mais j'ai réussi a le résoudre, il fallait juste changer le type de données à envoyer dans la fonction writecom:
fonction initiale-> int WriteCOM(char *Port,float TrameToSend)
fonction corrigée-> int WriteCOM(char *Port,Trame TrameToSend)

mais maintenant j'ai un autre souci il faut que je construise le Controle de Redondance Cyclique a partir de cette trame c'est a dire le Debut de trame et les 6 floattants.

N.B. emmatopiak il suffit de regarder des sources concernant la gestion du port serie (rs 232).
[auteurdetail.aspx?ID=1018277 ]
0
emmatopiak Messages postés 149 Date d'inscription mercredi 28 mars 2007 Statut Membre Dernière intervention 17 mai 2007 2
14 mai 2007 à 14:04
Salut,

les sources concernant le port serie ? les sources de quoi ? du noyau linux ?
_ je regarde pas des sources pour voir les entetes des fonctions, je regarde de la documentation
_ et j'en ai pas trouve' sur writeCOM de mon cote :p

Une autruche ne se cuit pas aux petits lardons.
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
emmatopiak Messages postés 149 Date d'inscription mercredi 28 mars 2007 Statut Membre Dernière intervention 17 mai 2007 2
14 mai 2007 à 14:08
RE

Sinon, pour ta seconde question:

Il faut que tu saches quel est l'algo de CRC utilisé puis tu construis une structure juste avec les champs voulus (le debut de la trame et les 6 flottants) et tu passes ton algo dessus regarde dans les sources vu que l'algo changera pas, ca t'evitera les erreurs :p

Une autruche ne se cuit pas aux petits lardons.
0
salsou34 Messages postés 9 Date d'inscription mardi 10 avril 2007 Statut Membre Dernière intervention 29 mai 2007
14 mai 2007 à 14:15
Salut,
Voici le programme sur lequel je bosse:

#include <windows.h>
#include <conio.h>
#include <shlwapi.h>
#include <stdio.h>
#include "structure.h"

/*---------------------------------------------------------------------------------------------*/
/*                 DECLARATION DE LA FONCTION DE CONFIGURATION DU PORT RS232                   */
/*---------------------------------------------------------------------------------------------*/
int InitCOM(char *,char *,char *,char *,char *);
/*---------------------------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------------------*/
/*                              DECLARATION DE LA FONCTION D'ECRITURE                               */
/*---------------------------------------------------------------------------------------------*/
int WriteCOM(char *,Trame);
/*---------------------------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------------------*/
/*                              DECLARATION DE LA FONCTION DE LECTURE                               */
/*---------------------------------------------------------------------------------------------*/
int ReadCOM(char *);
/*---------------------------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------------------*/
/*                            FONCTION DE CONFIGURATION DU PORT RS232                               */
/*---------------------------------------------------------------------------------------------*/
int InitCOM(char *Port,char *Parite,char *Vitesse,char *Data,char *StopBit)
{
    DCB dcb;            //Déclaration d'une variable contenant la configuration du port
    HANDLE hCom;        //Déclaration d'un HANDLE
    DWORD dwError;        //Numéro de l'erreur
    BOOL fSuccess;        //Tout s'est bien passé

    /*----------------------------------------------------*/
    /*                Ouverture du port COM                  */
    /*----------------------------------------------------*/
    hCom=CreateFile(
        Port,                            //Choix du Port "COMx"
        GENERIC_READ|GENERIC_WRITE,        //Accès pour lire et écrire sur le port
        0,                                //Accès exclusif au port COM
        NULL,                            //Sécurité par défaut
        OPEN_EXISTING,                    //Doit être à cette valeur car ce n'est pas un fichier
        0,                                //
        NULL);                            //Mode synchrone
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*     Vérifier que le handle est ouvert correctement   */
    /*----------------------------------------------------*/
    if(hCom==INVALID_HANDLE_VALUE)
    {
        dwError=GetLastError();            //On récupère le numéro de l'erreur
    }
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*       Récupération de la configuration existante      */
    /*----------------------------------------------------*/
    fSuccess=GetCommState(hCom,&dcb);
    if(!fSuccess)
    {
        //Ecrire ici le programme qui gère les erreurs
    }
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*               Définition des paramètres              */
    /*----------------------------------------------------*/
    dcb.DCBlength=sizeof(DCB);            //Taille de la structure

    dcb.BaudRate=StrToInt(Vitesse);        //Définition de la vitesse

    dcb.fBinary=TRUE;                    //Mode binaire
    dcb.fParity=FALSE;                    //Sans vérification de la parité
    dcb.fOutxCtsFlow=FALSE;               
    dcb.fOutxDsrFlow=FALSE;
    dcb.fDtrControl=FALSE;
    dcb.fDsrSensitivity=FALSE;
    dcb.fTXContinueOnXoff=FALSE;
    dcb.fRtsControl=FALSE;

    dcb.ByteSize=StrToInt(Data);        //Définition de la taille de la trame

    if(strcmp(Parite,"Aucune")==0)        //
        dcb.Parity=NOPARITY;            //
    if(strcmp(Parite,"Paire")==0)        //Definition de la parité
        dcb.Parity=EVENPARITY;            //
    if(strcmp(Parite,"Impaire")==0)        //
        dcb.Parity=ODDPARITY;            //

    if(strcmp(StopBit,"1")==0)            //
        dcb.StopBits=ONESTOPBIT;        //
    if(strcmp(StopBit,"1.5")==0)        //Définition du nombre de bits de stop
        dcb.StopBits=ONE5STOPBITS;        //
    if(strcmp(StopBit,"2")==0)            //
        dcb.StopBits=TWOSTOPBITS;        //
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*                 Mise à jour du port                  */
    /*----------------------------------------------------*/
    fSuccess=SetCommState(hCom,&dcb);
    if(!fSuccess)
    {
        //Ecrire ici le programme qui gère les erreurs
    }
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*                 Fermeture du port COM                  */
    /*----------------------------------------------------*/
    getch();
    CloseHandle(hCom);
    /*----------------------------------------------------*/

    return 0;
}
/*---------------------------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------------------*/
/*                                      FONCTION D'ECRITURE                                       */
/*---------------------------------------------------------------------------------------------*/
int WriteCOM(char *Port,Trame TrameToSend)
{
    HANDLE hCom;                    //Déclaration d'un HANDLE
    DWORD dwError;                    //Numéro de l'erreur
    DWORD dwNumBytesWritten;        //Variable qui contiendra le nombre d'octets écrit dans le buffer
    BOOL WriteError;

    /*----------------------------------------------------*/
    /*                 Ouverture du port COM                  */
    /*----------------------------------------------------*/
    hCom=CreateFile(
        Port,                            //Choix du Port "COMx"
        GENERIC_READ|GENERIC_WRITE,        //Accès pour lire et écrire sur le port
        0,                                //Accès exclusif au port COM
        NULL,                            //Sécurité par défaut
        OPEN_EXISTING,                    //Doit être à cette valeur car ce n'est pas un fichier
        0,                                //
        NULL);                            //Mode synchrone
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*     Vérifier que le handle est ouvert correctement   */
    /*----------------------------------------------------*/
    if(hCom==INVALID_HANDLE_VALUE)
    {
        dwError=GetLastError();            //On récupère le numéro de l'erreur
    }
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*                   Envoi des données                  */
    /*----------------------------------------------------*/
    WriteError=WriteFile(
        hCom,                        //Instance d'accès du port série
        &TrameToSend,                //Pointeur sur la donnée à envoyer
        25,                            //Nombre d'octets à envoyer
        &dwNumBytesWritten,            //Adresse d'une variable 32 bits dans laquelle Windows fera une copie
        NULL);
    if(!WriteError)
    {
        //Ecrire ici le programme qui gère les erreurs
    }
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*                Fermeture du port COM                  */
    /*----------------------------------------------------*/
    CloseHandle(hCom);
    /*----------------------------------------------------*/

    return 0;
}
/*---------------------------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------------------------*/
/*                                      FONCTION DE LECTURE                                       */
/*---------------------------------------------------------------------------------------------*/
int ReadCOM(char *Port)
{
    int TrameReceived;
    HANDLE hCom;                    //Déclaration d'un HANDLE
    DWORD dwError;                    //Numéro de l'erreur
    DWORD dwBytesTransferred;
    DWORD dwCommStatus;
    BOOL ReadError;

    /*----------------------------------------------------*/
    /*                 Ouverture du port COM                  */
    /*----------------------------------------------------*/
    hCom=CreateFile(
        Port,                            //Choix du Port "COMx"
        GENERIC_READ|GENERIC_WRITE,        //Accès pour lire et écrire sur le port
        0,                                //Accès exclusif au port COM
        NULL,                            //Sécurité par défaut
        OPEN_EXISTING,                    //Doit être à cette valeur car ce n'est pas un fichier
        0,                                //
        NULL);                            //Mode synchrone
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*     Vérifier que le handle est ouvert correctement   */
    /*----------------------------------------------------*/
    if(hCom==INVALID_HANDLE_VALUE)
    {
        dwError=GetLastError();            //On récupère le numéro de l'erreur
    }
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*           Définition du masque d'événements          */
    /*----------------------------------------------------*/
    SetCommMask(
        hCom,
        EV_RXCHAR);            //Ici EV_RXCHAR indique que l'on va détecter la réception de données
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*     Attente d'un événement définit dans le masque      */
    /*----------------------------------------------------*/
    WaitCommEvent(
        hCom,
        &dwCommStatus,
        0);
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*                   Réception des données              */
    /*----------------------------------------------------*/
    ReadError=ReadFile(
        hCom,                        //Instance d'accès au port COM
        &TrameReceived,                //Pointeur sur la donnée à envoyer
        25,                            //Nombre d'octets à recevoir
        &dwBytesTransferred,        //Adresse d'une variable 32 bits dans laquelle Windows fera une copie
        NULL);
    if(!ReadError)
    {
        //Ecrire ici le programme qui gère les erreurs
    }
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*              Affichage de la trame reçue              */
    /*----------------------------------------------------*/
    //printf("La trame recue est : %l\n",TrameReceived);
    /*----------------------------------------------------*/

    /*----------------------------------------------------*/
    /*                Fermeture du port COM                  */
    /*----------------------------------------------------*/
    CloseHandle(hCom);
    /*----------------------------------------------------*/

    return (TrameReceived);
}
/*---------------------------------------------------------------------------------------------*/

En esperant que ça réponde a ta question, sinon peut tu être plus explicite sur ta réponse concernant le crc.
merci :)
0
emmatopiak Messages postés 149 Date d'inscription mercredi 28 mars 2007 Statut Membre Dernière intervention 17 mai 2007 2
14 mai 2007 à 14:55
RE

1) je te demande pour writeCOM et tu me dis de voir les sources. Tu me demandes pour CRC je te dis de voir les sources
2) tu dois faire un calcul de CRC sur quelques champs. Il faut mettre tous ces champs dans une structure commune
3) quand tu auras mis tout dans la structure commune, lance la fonction de calcul de CRC.
Deux possibilites la:
3a) tu sais faire la fonction de CRC. Ben du coup tu la fais :p
(3b) tu ne sais pas faire la fonction de CRC et tu ne la trouves pas dans les sources. Si c'est le cas, cherche sur google quel est l'algo de CRC pour les liaisons series et implemente le.

*Mais c'est forcement dans les sources donc tu vas trouver en cherchant bien.
Une autruche ne se cuit pas aux petits lardons.
0
dhiaCS Messages postés 1 Date d'inscription samedi 31 mars 2012 Statut Membre Dernière intervention 9 juillet 2012
9 juil. 2012 à 20:51
Bonjour salsou34,est ce que vous pouvez m'envoyer le fichier structure.c?
0
salsou34 Messages postés 9 Date d'inscription mardi 10 avril 2007 Statut Membre Dernière intervention 29 mai 2007
9 juil. 2012 à 23:12
Bonjour,

Désolé 5 ans après je ne peut plus rien pour toi.
0
Rejoignez-nous