IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Embarqué Discussion :

Recupérer des données sous linux du port RS232


Sujet :

Embarqué

  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    Décembre 2007
    Messages
    560
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2007
    Messages : 560
    Points : 71
    Points
    71
    Par défaut Recupérer des données sous linux du port RS232
    Bonjour,
    je suis en train d'essayer de récuperer des données par RS232 sur mon PC. J'ai trouvé un lien sur internet permettant de récupérer les données sur le port référencé:
    http://www.faqs.org/docs/Linux-HOWTO...ing-HOWTO.html

    J'ai essayé le programme du chapitre Asynchronous Input mais je n'arrive pas à recevoir des infos sur le port. Voici donc le programme :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    #include <unistd.h>
    #include <stdlib.h>
    #include <strings.h>
    
    
    
    #include <termios.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <sys/signal.h>
    #include <sys/types.h>
    
    #define BAUDRATE B9600
    #define MODEMDEVICE "/dev/ttyUSB0"
    #define _POSIX_SOURCE 1 /* POSIX compliant source */
    #define FALSE 0
    #define TRUE 1
    
    volatile int STOP=FALSE;
    
    void signal_handler_IO (int status);   /* definition of signal handler */
    int wait_flag=TRUE;                    /* TRUE while no signal received */
    
    main()
    {
        int fd,c, res;
        struct termios oldtio,newtio;
        struct sigaction saio;           /* definition of signal action */
        char buf[255];
    
        __sigset_t t;
    
        /* open the device to be non-blocking (read will return immediatly) */
        fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK);
        if (fd <0) {perror(MODEMDEVICE); exit(-1); }
    
        cout << "file " << fd << endl;
        /* install the signal handler before making the device asynchronous */
        saio.sa_handler = signal_handler_IO;
        saio.sa_mask = t;
        saio.sa_flags = 0;
        saio.sa_restorer = NULL;
        sigaction(SIGIO,&saio,NULL);
    
        /* allow the process to receive SIGIO */
        fcntl(fd, F_SETOWN, getpid());
        /* Make the file descriptor asynchronous (the manual page says only
               O_APPEND and O_NONBLOCK, will work with F_SETFL...) */
        fcntl(fd, F_SETFL, FASYNC);
    
        tcgetattr(fd,&oldtio); /* save current port settings */
        /* set new port settings for canonical input processing */
        newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
        newtio.c_iflag = IGNPAR | ICRNL;
        newtio.c_oflag = 0;
        newtio.c_lflag = ICANON;
        newtio.c_cc[VMIN]=1;
        newtio.c_cc[VTIME]=0;
        tcflush(fd, TCIFLUSH);
        tcsetattr(fd,TCSANOW,&newtio);
    
        /* loop while waiting for input. normally we would do something
               useful here */
        while (STOP==FALSE) {
    //        cout << "lo" << endl;
    //        printf(".\n");usleep(10);
            /* after receiving SIGIO, wait_flag = FALSE, input is available
                 and can be read */
            if (wait_flag==FALSE) {
                res = read(fd,buf,1);
                buf[res]=0;
                printf("received:%s:%d\n", buf, res);
                if (res==1) STOP=TRUE; /* stop loop if only a CR was input */
                wait_flag = TRUE;      /* wait for new input */
            }
        }
        /* restore old port settings */
        tcsetattr(fd,TCSANOW,&oldtio);
    }

    Quelqu'un aurait-il déja essayé ce programme sur son ordinateur?
    Pourquoi le programme se bloque dans la partie "res = read(fd,buf,1);"?

    si quelqu'un pouvait m'aider.

    D'avance merci.

  2. #2
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Juin 2009
    Messages
    4 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués

    Informations forums :
    Inscription : Juin 2009
    Messages : 4 481
    Points : 13 678
    Points
    13 678
    Billets dans le blog
    1
    Par défaut
    Je vais faire une réponse de principe : read() est une fonction bloquante* tant qu'aucun donnée n'est disponible, y a t-il des données entrantes sur le port série ? Pour le savoir, utiliser un utilitaire tel que gtkterm pour afficher les données qui arrivent sur le port de ton choix.

    * : code semble dire que tu as réglé pour être en read() non bloquant, es-tu sûr de tes options ? N'est-ce pas un peu contradictoire ?

    On n'utilise plus cette écriture pour le main depuis bien longtemps !

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    cout << "file " << fd << endl;
    Oula ! Que vient faire du code C++ là dedans ? Tu n'as pas inclus <iostream> mais <stdio.h>, tu devrais donc faire du C et non du C++.

  3. #3
    Membre régulier
    Profil pro
    Inscrit en
    Décembre 2007
    Messages
    560
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2007
    Messages : 560
    Points : 71
    Points
    71
    Par défaut
    Oui effectivement j'ai repris un code en faisant un copier-coller. Donc j'ai du faire des erreurs. En suite je compile sous Qt, j'en ai donc profité pour utiliser le cout en C++.

    Voici le code actuel avec la gestion du read pour éviter les problèmes de bloquage:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    #include <unistd.h>
    #include <stdlib.h>
    #include <strings.h>
    
    
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <termios.h>
    #include <stdio.h>
    
    #define BAUDRATE B9600
    #define MODEMDEVICE "/dev/ttyUSB0"
    #define _POSIX_SOURCE 1 /* POSIX compliant source */
    #define FALSE 0
    #define TRUE 1
    
    volatile int STOP=FALSE;
    
    volatile int wait_flag = FALSE;
    
    void signal_handler_IO (int status);
    #include <termios.h>
    #include <stdio.h>
    #include <unistd.h>
    #include <fcntl.h>
    #include <sys/signal.h>
    #include <sys/types.h>
    
    
    #include <iostream>
    using namespace std;
    
    int main(void)
    {
        int fd,c, res;
        struct termios oldtio,newtio;
        struct sigaction saio;           /* definition of signal action */
        char buf[255];
    
        fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY |O_NDELAY);
        if (fd <0) {perror(MODEMDEVICE); exit(-1); }
    
    
        /* install the signal handler before making the device asynchronous */
        __sigset_t t;
        saio.sa_handler = signal_handler_IO;
        saio.sa_mask = t;
        saio.sa_flags = 0;
        saio.sa_restorer = NULL;
        sigaction(SIGIO,&saio,NULL);
    
        /* allow the process to receive SIGIO */
        fcntl(fd, F_SETOWN, getpid());
        /* Make the file descriptor asynchronous (the manual page says only
                   O_APPEND and O_NONBLOCK, will work with F_SETFL...) */
        fcntl(fd, F_SETFL, FASYNC);
    
        tcgetattr(fd,&oldtio); /* save current port settings */
    
        bzero(&newtio, sizeof(newtio));
        newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
        newtio.c_iflag = IGNPAR;
        newtio.c_oflag = 0;
    
    
        /* set input mode (non-canonical, no echo,...) */
        newtio.c_lflag = 0;
    
        newtio.c_cc[VTIME]    = 0;   /* inter-character timer unused */
        newtio.c_cc[VMIN]     = 0;   /* blocking read until 5 chars received */
    
        tcflush(fd, TCIFLUSH);
        tcsetattr(fd,TCSANOW,&newtio);
    
    
        while (STOP==FALSE) {       /* loop for input */
            printf(".\n");usleep(100000);
            if(!wait_flag)
            {
                res = read(fd,buf,255);   /* returns after 5 chars have been input */
                buf[res]=0;
                printf(":%s:%d\n", buf, res);
                wait_flag = TRUE;
            }
            res = write(fd,"recu",4);   /* returns after 5 chars have been input */
            printf("emit: %d",res);
            /* so we can printf... */
    
    
            if (buf[0]=='z') STOP=TRUE;
        }
        tcsetattr(fd,TCSANOW,&oldtio);
    
        exit(0);
    }
    
    
    /***************************************************************************
          * signal handler. sets wait_flag to FALSE, to indicate above loop that     *
          * characters have been received.                                           *
          ***************************************************************************/
    
    void signal_handler_IO (int status)
    {
        printf("received SIGIO signal.\n");
        wait_flag = FALSE;
    }

    Le problème que j'ai maintenant c'est que les données ne sont pas envoyées. Aurais-je fait une erreur dans les options que j'ai mis?

  4. #4
    Modérateur

    Avatar de Bktero
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Juin 2009
    Messages
    4 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués

    Informations forums :
    Inscription : Juin 2009
    Messages : 4 481
    Points : 13 678
    Points
    13 678
    Billets dans le blog
    1
    Par défaut
    Si tu utilises Qt, pourquoi ne pas utiliser les modules dédiés aux ports séries : http://qt-project.org/wiki/QtSerialPort

    N'ayant jamais programmé avec les ports séries sous Linux, mes compétences s'arrêteront là, désolé : /

  5. #5
    Membre régulier
    Profil pro
    Inscrit en
    Décembre 2007
    Messages
    560
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2007
    Messages : 560
    Points : 71
    Points
    71
    Par défaut Re
    Je me sers de QTcreator comme IDE pour programmer , je trouve ca plus simple qu'avec Emacs.
    Ensuite je voudrais a terme me faire un système de traitement du RS232 light pour des microprocesseurs embarqués.

Discussions similaires

  1. VmWare sous XP: partager des données avec Linux
    Par EvilAngel dans le forum VMware
    Réponses: 18
    Dernier message: 06/01/2009, 14h03
  2. lecture/ecriture des broches RTS/CTS du port RS232
    Par .:: sly51 ::. dans le forum C
    Réponses: 3
    Dernier message: 24/10/2006, 16h28
  3. Exporter des données sous forme de requetes
    Par Pasiphae dans le forum MS SQL Server
    Réponses: 6
    Dernier message: 06/10/2004, 18h27
  4. mise a jours des données sous access
    Par puyopuyo dans le forum ASP
    Réponses: 4
    Dernier message: 25/05/2004, 13h46
  5. Rediriger un flux de données sous linux
    Par Nicaisse dans le forum POSIX
    Réponses: 7
    Dernier message: 01/07/2003, 17h04

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo