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

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 :)

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.

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

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.

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.

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 :)

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.