Répondre à la discussion
Affichage des résultats 1 à 4 sur 4

Communication série RS232 en langage C




  1. #1
    Elbuey76

    Communication série RS232 en langage C

    Bonjour à tous !

    J'ai créé ce sujet car j'ai un petit probleme avec un programme en langage C.
    Il s'agit d'une source que j'ai trouvé sur le net, je l'ai telechargé et je l'ai compilé avec Dev-cpp.
    C'est un programme qui permet d'échanger des données sur un port serie.

    Au debut le programme marchait, puis après l'avoir lancer 2 ou 3 fois, il est impossible de quitter le programme en tapant le choix n°3, c'est a dire "quitter".
    J'ai executer le programme en mode pas a pas, le programme rentre dans la fonction CloseCom(); (qui sert a fermer le port avant de quitter) mais elle reste bloqué sur la fonction WriteFile(); sans allé plus loin, ce qui a pour effet sur l'ecran de l'ordi de planter en "figeant" le programme.
    Je tiens a signaler aussi que parfois en compilant le compilateur m'indique "permission denied, return -1" ou quelque chose du genre, je ne l'ai plus en tete, et cela sans m'indiquer de ligne ou de fonction.



    Si quelqu'un a une idée, je suis preneur, vous etes mon seul moyen de m'en tiré, je ne peu pas demander a mes prof du fait qu'il faut un port serie et etc..., pour executer le programme (je ne peut pas transporter l'ordi).

    Je poste le code juste après.

    Bonne soirée a tous et merci pour votre aide.



    Code:
    /******************************************************************************
      TestCOM.c :
      
       fonctions de base pour l'envoi et la réception de donner sur un port
       série RS232.
    ******************************************************************************/
    
    #include <windows.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <conio.h>
    
    /*=============================================================================
      Définition de constantes
    =============================================================================*/
    #define RX_SIZE         4096    /* taille tampon d'entrée  */
    #define TX_SIZE         4096    /* taille tampon de sortie */
    #define MAX_WAIT_READ   5000    /* temps max d'attente pour lecture (en ms) */
    
    
    /*=============================================================================
      Variables globales.
    =============================================================================*/
    
    /* Handle du port COM ouvert */
    HANDLE g_hCOM = NULL;
    
    /* Délais d'attente sur le port COM */
    COMMTIMEOUTS g_cto =
    {
        MAX_WAIT_READ,  /* ReadIntervalTimeOut          */
        0,              /* ReadTotalTimeOutMultiplier   */
        MAX_WAIT_READ,  /* ReadTotalTimeOutConstant     */
        0,              /* WriteTotalTimeOutMultiplier  */
        0               /* WriteTotalTimeOutConstant    */
    };
    
    /* Configuration du port COM */
    DCB g_dcb =
    {
        sizeof(DCB),        /* DCBlength            */
        9600,               /* BaudRate             */
        TRUE,               /* fBinary              */
        FALSE,              /* fParity              */
        FALSE,              /* fOutxCtsFlow         */
        FALSE,              /* fOutxDsrFlow         */
        DTR_CONTROL_ENABLE, /* fDtrControl          */
        FALSE,              /* fDsrSensitivity      */
        FALSE,              /* fTXContinueOnXoff    */
        FALSE,              /* fOutX                */
        FALSE,              /* fInX                 */
        FALSE,              /* fErrorChar           */
        FALSE,              /* fNull                */
        RTS_CONTROL_ENABLE, /* fRtsControl          */
        FALSE,              /* fAbortOnError        */
        0,                  /* fDummy2              */
        0,                  /* wReserved            */
        0x100,              /* XonLim               */
        0x100,              /* XoffLim              */
        8,                  /* ByteSize             */
        NOPARITY,           /* Parity               */
        ONESTOPBIT,         /* StopBits             */
        0x11,               /* XonChar              */
        0x13,               /* XoffChar             */
        '?',                /* ErrorChar            */
        0x1A,               /* EofChar              */
        0x10                /* EvtChar              */
    };
    
    /*=============================================================================
      Fonctions du module.
    =============================================================================*/
    BOOL OpenCOM    (int nId);
    BOOL CloseCOM   ();
    BOOL ReadCOM    (void* buffer, int nBytesToRead, int* pBytesRead);
    BOOL WriteCOM   (void* buffer, int nBytesToWrite, int* pBytesWritten);
    
    /******************************************************************************
      main : point d'entrée du programme.
    ******************************************************************************/
    int main()
    {
        /* variables locales */
        char buffer[256];
        int nId, nChoice, nBytesWritten, nBytesRead;
    
        /* demande du numéro du port COM */
        printf("Entrez le numero du port COM : ");
        scanf("%d", &nId);
    
        /* tentative d'ouverture */
        printf("Ouverture et configuration du port COM%d...\r\n", nId);
        if(!OpenCOM(nId)) return -1;
        printf("...OK\r\n");
    
        /* boucle tant que l'on ne quitte pas */
        do
        {
            /* menu */
            printf("\r\n");
            printf("1 : Envoyer des donnees.\r\n");
            printf("2 : Recevoir des donnees.\r\n");
            printf("3 : Quitter.\r\n");
            printf("Choix : ");
            scanf("%d", &nChoice);
    
            /* enoyer des données */
            if(nChoice == 1)
            {
                printf("\r\n");
                printf("Donnees a envoyer :\r\n");
                fflush(stdin);
                gets(buffer);
                printf("\r\n");
                printf("Envoi des donnees...\r\n");
                if(WriteCOM(buffer, strlen(buffer), &nBytesWritten))
                    printf("%d octet(s) envoye(s).\r\n", nBytesWritten);
                else
                    printf("Erreur lors de l'envoi.\r\n");
            }
    
            /* recevoir des données */
            if(nChoice == 2)
            {
                printf("\r\n");
                printf("Reception de donnees...\r\n");
                if(ReadCOM(buffer, sizeof(buffer)-1, &nBytesRead))
                {
                    buffer[nBytesRead] = '\0';
                    printf("%d octet(s) recu(s) :\r\n%s\r\n", nBytesRead, buffer);
                }
                else
                    printf("Erreur lors de la réception.\r\n");
            }
        }while(nChoice != 3);
    
        /* fermeture du port COM et retour */
        CloseCOM();
        return 0;
    }
    
    /******************************************************************************
      OpenCOM : ouverture et configuration du port COM.
      entrée : nId : Id du port COM à ouvrir.
      retour : vrai si l'opération a réussi, faux sinon.
    ******************************************************************************/
    BOOL OpenCOM(int nId)
    {
        /* variables locales */
        char szCOM[16];
    
        /* construction du nom du port, tentative d'ouverture */
        sprintf(szCOM, "COM%d", nId);
        g_hCOM = CreateFile(szCOM, GENERIC_READ|GENERIC_WRITE, 0, NULL,
                            OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
        if(g_hCOM == INVALID_HANDLE_VALUE)
        {
            printf("Erreur lors de l'ouverture du port COM%d", nId);
            return FALSE;
        }
    
        /* affectation taille des tampons d'émission et de réception */
        SetupComm(g_hCOM, RX_SIZE, TX_SIZE);
    
        /* configuration du port COM */
        if(!SetCommTimeouts(g_hCOM, &g_cto) || !SetCommState(g_hCOM, &g_dcb))
        {
            printf("Erreur lors de la configuration du port COM%d", nId);
            CloseHandle(g_hCOM);
            return FALSE;
        }
    
        /* on vide les tampons d'émission et de réception, mise à 1 DTR */
        PurgeComm(g_hCOM, PURGE_TXCLEAR|PURGE_RXCLEAR|PURGE_TXABORT|PURGE_RXABORT);
        EscapeCommFunction(g_hCOM, SETDTR);
        return TRUE;
    }
    
    /******************************************************************************
      CloseCOM : fermeture du port COM.
      retour : vrai si l'opération a réussi, faux sinon.
    ******************************************************************************/
    BOOL CloseCOM()
    {
        /* fermeture du port COM */
        CloseHandle(g_hCOM);
        return TRUE;
    }
    
    /******************************************************************************
      ReadCOM : lecture de données sur le port COM.
      entrée : buffer       : buffer où mettre les données lues.
               nBytesToRead : nombre max d'octets à lire.
               pBytesRead   : variable qui va recevoir le nombre d'octets lus.
      retour : vrai si l'opération a réussi, faux sinon.
    -------------------------------------------------------------------------------
      Remarques : - la constante MAX_WAIT_READ utilisée dans la structure
                    COMMTIMEOUTS permet de limiter le temps d'attente si aucun
                    caractères n'est présent dans le tampon d'entrée.
                  - la fonction peut donc retourner vrai sans avoir lu de données.
    ******************************************************************************/
    BOOL ReadCOM(void* buffer, int nBytesToRead, int* pBytesRead)
    {
        return ReadFile(g_hCOM, buffer, nBytesToRead, pBytesRead, NULL);
    }
    
    /******************************************************************************
      WriteCOM : envoi de données sur le port COM.
      entrée : buffer        : buffer avec les données à envoyer.
               nBytesToWrite : nombre d'octets à envoyer.
               pBytesWritten : variable qui va recevoir le nombre d'octets
                               envoyés.
      retour : vrai si l'opération a réussi, faux sinon.
    ******************************************************************************/
    BOOL WriteCOM(void* buffer, int nBytesToWrite, int* pBytesWritten)
    {
        /* écriture sur le port */
        return WriteFile(g_hCOM, buffer, nBytesToWrite, pBytesWritten, NULL);
    }

    -----


  2. Publicité
  3. #2
    Elbuey76

    Re : Communication série RS232 en langage C

    Je viens de trouver en partie la solution, le programme reste figé car j'ai baissé la vitesse a 2 bauds pour y voir quelque chose sur mon vieil oscillo.
    A 9600 bauds, il n'y a aucun probleme.
    Mais je me demande quelque chose, pourquoi je vois mes données sur l'oscillo et qu'aprés il y a un temps (3 minute environ) ou il ne fait rien avant d'executer closehandle() ? envoi-t-il des 0 ?

  4. #3
    Rendar

    Re : Communication série RS232 en langage C

    Salut Elbuey76,
    je doit aussi créer un programme qui communique via RS232.
    Est-ce que tu pourrais m'expliquer ce qui est necessaire pour la communication?
    Ce que je recherche c'est la partie configuration en langage C et la partie commande pour envoyer une valeur et la recevoir avec la liaison RS232(comment faut-il la programmer).

    Pour info j'utilise le langage C avec CodeBlocks en console application

    Entre GEII on s'entraide ^^


  5. #4
    LABTOOL48

    Re : Communication série RS232 en langage C

    Citation Envoyé par Rendar Voir le message
    Salut Elbuey76,
    je doit aussi créer un programme qui communique via RS232.
    Est-ce que tu pourrais m'expliquer ce qui est necessaire pour la communication?
    Ce que je recherche c'est la partie configuration en langage C et la partie commande pour envoyer une valeur et la recevoir avec la liaison RS232(comment faut-il la programmer).

    Pour info j'utilise le langage C avec CodeBlocks en console application

    Entre GEII on s'entraide ^^
    le code donnée par Elbuey76 c'est le minimum pour communiquer sur le portcom , pour la configuration de portcom voir "DCB" code
    /* Configuration du port COM */
    DCB g_dcb =
    {
    sizeof(DCB), /* DCBlength */
    9600, /* BaudRate */
    TRUE, /* fBinary */
    FALSE, /* fParity */
    FALSE, /* fOutxCtsFlow */
    FALSE, /* fOutxDsrFlow */
    DTR_CONTROL_ENABLE, /* fDtrControl */
    FALSE, /* fDsrSensitivity */
    FALSE, /* fTXContinueOnXoff */
    FALSE, /* fOutX */
    FALSE, /* fInX */
    FALSE, /* fErrorChar */
    FALSE, /* fNull */
    RTS_CONTROL_ENABLE, /* fRtsControl */
    FALSE, /* fAbortOnError */
    0, /* fDummy2 */
    0, /* wReserved */
    0x100, /* XonLim */
    0x100, /* XoffLim */
    8, /* ByteSize */
    NOPARITY, /* Parity */
    ONESTOPBIT, /* StopBits */
    0x11, /* XonChar */
    0x13, /* XoffChar */
    '?', /* ErrorChar */
    0x1A, /* EofChar */
    0x10 /* EvtChar */
    };
    le DCB c'est une variable de type structure utiliser par le control de portcom (chipset qui gère le portcom ) et le COMMTIMEOUTS
    COMMTIMEOUTS g_cto =
    {
    MAX_WAIT_READ, /* ReadIntervalTimeOut */
    0, /* ReadTotalTimeOutMultiplier */
    MAX_WAIT_READ, /* ReadTotalTimeOutConstant */
    0, /* WriteTotalTimeOutMultiplier */
    0 /* WriteTotalTimeOutConstant */
    };
    on utilise cette variable c'est apres l'appelle de la fonction ReadCOM(); ne recevra rien on quitte la fonction ReadCOM apres le TimeOutMultiplier terminé

    le reste est claire désolé pour la langue et bonne chance

Discussions similaires

  1. Communication Port RS232 - USB
    Par Samo2705 dans le forum Électronique
    Réponses: 4
    Dernier message: 31/03/2008, 01h44
  2. communication pic rs232
    Par alainav1 dans le forum Électronique
    Réponses: 14
    Dernier message: 24/03/2008, 16h03
  3. communication par rs232
    Par the_lightner dans le forum Électronique
    Réponses: 14
    Dernier message: 18/07/2007, 11h24
  4. Pic16f876A/communication RS232
    Par Bidebuster dans le forum Électronique
    Réponses: 8
    Dernier message: 23/05/2007, 11h15
  5. Communication GSM/PC via rs232
    Par zanzeoo dans le forum Électronique
    Réponses: 4
    Dernier message: 25/09/2006, 12h40