Je suis en train d'écrire une application C/C++ qui dialogue avec une
interface électronique par le biais d'un port série /dev/ttyS0. Il
s'agit d'une communication asynchrone, même si dans 90% des cas, c'est
mon application qui émet une trame puis l'interface qui répond.
J'ai pour le moment trouvé que deux solutions, mais aucunes des deux me
semble correcte. Cependant, je vous les expose.
Première)
1 Je lis de manière bloquante le fichier /dev/ttS0 pendant 1 seconde.
2 Si j'ai un réponse, je traite puis je continu, sinon je continu
3 Si j'ai une trame à émettre, je l'émet
4 Je reviens à l'étape 1
Ce n'est pas très élégant, on boucle en permanence.
Deuxième)
1 Je crée un premier thread de lecture bloquante
T1
1 Je lis de manière bloquante et définitve cette fois-ci.
2 Je viens de recevoir une réponse, je la traite
3 Je reviens à l'etape 1
2 Je créé un deuxième thread
T2
1 J'attend un quelquonque évenement (touche clavier par exemple)
2 J'emet une trame
3 Je reviens à l'étape 1
Cette façon n'est pas meilleur, car elle est trés lourde. Il faut à la
fois mettre en place un mécanisme de protection du descripteur de
fichier. Mais aussi, un mécanisme de synchronisation entre ces 2
threads, car chque fois que j'emet une trame je dois attendre un accuse
de l'interface et inversement, si l'interface m'envoit une
trame, je dois emettre un accusé + quelques cas particulier.
Vous en pensez quoi? J'attends vos avis avec impatience.
Vous en pensez quoi? J'attends vos avis avec impatience.
Que ce n'est pas une question de langage C, mais de conception... -- A+
Emmanuel Delahaye
Harpo
Teddy311 wrote:
J'ai pour le moment trouvé que deux solutions, mais aucunes des deux me semble correcte.
Je n'y connais rien et je ne suis pas sûr d'avoir compris la question, essaie 'man select' et 'man ioctl' dans un premier temps. Il est possible que d'autres NG soient avides des résultats.
-- http://patrick.davalan.free.fr/
Teddy311 wrote:
J'ai pour le moment trouvé que deux solutions, mais aucunes des deux
me semble correcte.
Je n'y connais rien et je ne suis pas sûr d'avoir compris la question,
essaie 'man select' et 'man ioctl' dans un premier temps.
Il est possible que d'autres NG soient avides des résultats.
J'ai pour le moment trouvé que deux solutions, mais aucunes des deux me semble correcte.
Je n'y connais rien et je ne suis pas sûr d'avoir compris la question, essaie 'man select' et 'man ioctl' dans un premier temps. Il est possible que d'autres NG soient avides des résultats.
-- http://patrick.davalan.free.fr/
Teddy311
http://linuxfr.org/forums/19/15463.html
Bonjour a tous/tes
Je suis en train d'écrire une application C/C++ qui dialogue avec une interface électronique par le biais d'un port série /dev/ttyS0. Il s'agit d'une communication asynchrone, même si dans 90% des cas, c'est mon application qui émet une trame puis l'interface qui répond.
J'ai pour le moment trouvé que deux solutions, mais aucunes des deux me semble correcte. Cependant, je vous les expose.
Première) 1 Je lis de manière bloquante le fichier /dev/ttS0 pendant 1 seconde. 2 Si j'ai un réponse, je traite puis je continu, sinon je continu 3 Si j'ai une trame à émettre, je l'émet 4 Je reviens à l'étape 1
Ce n'est pas très élégant, on boucle en permanence.
Deuxième) 1 Je crée un premier thread de lecture bloquante T1 1 Je lis de manière bloquante et définitve cette fois-ci. 2 Je viens de recevoir une réponse, je la traite 3 Je reviens à l'etape 1
2 Je créé un deuxième thread T2 1 J'attend un quelquonque évenement (touche clavier par exemple) 2 J'emet une trame 3 Je reviens à l'étape 1
Cette façon n'est pas meilleur, car elle est trés lourde. Il faut à la fois mettre en place un mécanisme de protection du descripteur de fichier. Mais aussi, un mécanisme de synchronisation entre ces 2 threads, car chque fois que j'emet une trame je dois attendre un accuse de l'interface et inversement, si l'interface m'envoit une trame, je dois emettre un accusé + quelques cas particulier.
Vous en pensez quoi? J'attends vos avis avec impatience.
http://linuxfr.org/forums/19/15463.html
Bonjour a tous/tes
Je suis en train d'écrire une application C/C++ qui dialogue avec une
interface électronique par le biais d'un port série /dev/ttyS0. Il
s'agit d'une communication asynchrone, même si dans 90% des cas, c'est
mon application qui émet une trame puis l'interface qui répond.
J'ai pour le moment trouvé que deux solutions, mais aucunes des deux me
semble correcte. Cependant, je vous les expose.
Première)
1 Je lis de manière bloquante le fichier /dev/ttS0 pendant 1 seconde.
2 Si j'ai un réponse, je traite puis je continu, sinon je continu
3 Si j'ai une trame à émettre, je l'émet
4 Je reviens à l'étape 1
Ce n'est pas très élégant, on boucle en permanence.
Deuxième)
1 Je crée un premier thread de lecture bloquante
T1
1 Je lis de manière bloquante et définitve cette fois-ci.
2 Je viens de recevoir une réponse, je la traite
3 Je reviens à l'etape 1
2 Je créé un deuxième thread
T2
1 J'attend un quelquonque évenement (touche clavier par exemple)
2 J'emet une trame
3 Je reviens à l'étape 1
Cette façon n'est pas meilleur, car elle est trés lourde. Il faut à la
fois mettre en place un mécanisme de protection du descripteur de
fichier. Mais aussi, un mécanisme de synchronisation entre ces 2
threads, car chque fois que j'emet une trame je dois attendre un accuse
de l'interface et inversement, si l'interface m'envoit une
trame, je dois emettre un accusé + quelques cas particulier.
Vous en pensez quoi? J'attends vos avis avec impatience.
Je suis en train d'écrire une application C/C++ qui dialogue avec une interface électronique par le biais d'un port série /dev/ttyS0. Il s'agit d'une communication asynchrone, même si dans 90% des cas, c'est mon application qui émet une trame puis l'interface qui répond.
J'ai pour le moment trouvé que deux solutions, mais aucunes des deux me semble correcte. Cependant, je vous les expose.
Première) 1 Je lis de manière bloquante le fichier /dev/ttS0 pendant 1 seconde. 2 Si j'ai un réponse, je traite puis je continu, sinon je continu 3 Si j'ai une trame à émettre, je l'émet 4 Je reviens à l'étape 1
Ce n'est pas très élégant, on boucle en permanence.
Deuxième) 1 Je crée un premier thread de lecture bloquante T1 1 Je lis de manière bloquante et définitve cette fois-ci. 2 Je viens de recevoir une réponse, je la traite 3 Je reviens à l'etape 1
2 Je créé un deuxième thread T2 1 J'attend un quelquonque évenement (touche clavier par exemple) 2 J'emet une trame 3 Je reviens à l'étape 1
Cette façon n'est pas meilleur, car elle est trés lourde. Il faut à la fois mettre en place un mécanisme de protection du descripteur de fichier. Mais aussi, un mécanisme de synchronisation entre ces 2 threads, car chque fois que j'emet une trame je dois attendre un accuse de l'interface et inversement, si l'interface m'envoit une trame, je dois emettre un accusé + quelques cas particulier.
Vous en pensez quoi? J'attends vos avis avec impatience.
