/usr/share/doc/HOWTO/fr-html/Serial-Programming-HOWTO.html is in doc-linux-fr-html 2013.01-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Linux (vers 25 March 2009), see www.w3.org">
<meta name="GENERATOR" content="LinuxDoc-Tools 0.9.71">
<title>Le Linux Serial Programming HOWTO</title>
</head>
<body>
<h1>Le Linux Serial Programming HOWTO</h1>
<h2>par Peter H. Baumann, <code><a href=
"mailto:Peter.Baumann@dlr.de">Peter.Baumann@dlr.de</a></code><br>
Adaptation française Etienne BERNARD <code><a href=
"mailto:eb@via.ecp.fr">eb@via.ecp.fr</a></code></h2>
v1.0, 22 janvier 1998
<hr>
<em>Ce document décrit comment programmer sous Linux la
communication avec des périphériques sur port
série.</em>
<hr>
<h2><a name="s1">1. Introduction</a></h2>
<p>Voici le Linux Serial Programming HOWTO, qui explique comment
programmer sous Linux la communication avec des
périphériques ou des ordinateurs via le port
série. Différentes techniques sont
abordées : Entrées/Sorties canoniques (envoi ou
réception ligne par ligne), asynchrones, ou l'attente de
données depuis de multiples sources.</p>
<p>Ce document ne décrit pas comment configurer les ports
séries, puisque c'est décrit par Greg Hankins dans le
Serial-HOWTO.</p>
<p>Je tiens à insister sur le fait que je ne suis pas un
expert dans ce domaine, mais j'ai eu à réaliser un
projet utilisant la communication par le port série. Les
exemples de code source présentés dans ce document
sont dérivés du programme <code>miniterm</code>,
disponible dans le <em>Linux programmer's guide</em>
(<code>ftp://sunsite.unc.edu/pub/Linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz</code>
et les miroirs, par exemple
<code>ftp://ftp.lip6.fr/pub/linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz</code>)
dans le répertoire contenant les exemples.</p>
<p>Depuis la dernière version de ce document, en juin 1997,
j'ai dû installer Windows NT pour satisfaire les besoins des
client, et donc je n'ai pas pu investiguer plus en avant sujet. Si
quelqu'un a des commentaires à me faire, je me ferai un
plaisir de les inclure dans ce document (voyez la section sur les
commentaires). Si vous désirez prendre en main
l'évolution de ce document, et l'améliorer, envoyez
moi un courrier électronique.</p>
<p>Tous les exemples ont été testés avec un
i386, utilisant un noyau Linux de version 2.0.29.</p>
<h2><a name="ss1.1">1.1 Copyright</a></h2>
<p>Le Linux Serial-Programming-HOWTO est copyright (c) 1997 Peter
Baumann. Les HOWTO de Linux peuvent être reproduits et
distribués intégralement ou seulement par partie, sur
quelconque support physique ou électronique, aussi longtemps
que ce message de copyright sera conservé dans toutes les
copies. Une redistribution commerciale est autorisée, et
encouragée; cependant, l'auteur <em>apprécierait</em>
d'être prévenu en cas de distribution de ce type.</p>
<p>Toutes les traductions ou travaux dérivés
incorporant un document HOWTO Linux doit être placé
sous ce copyright. C'est-à-dire que vous ne pouvez pas
produire de travaux dérivés à partir d'un
HOWTO et imposer des restrictions additionnelles sur sa
distribution. Des exceptions à cette règle peuvent
être accordées sous certaines conditions ;
contactez le coordinateur des HOWTO Linux à l'adresse
donnée ci-dessous.</p>
<p>En résumé, nous désirons promouvoir la
distribution de cette information par tous les moyens possibles.
Néanmoins, nous désirons conserver le copyright sur
les documents HOWTO, et nous <em>aimerions</em> être
informés de tout projet de redistribution des HOWTO.</p>
<p>Pour toute question, veuillez contacter Greg Hankins, le
coordinateur des HOWTO Linux, à <code><a href=
"mailto:gregh@sunsite.unc.edu">gregh@sunsite.unc.edu</a></code> par
mail.</p>
<h2><a name="ss1.2">1.2 Nouvelles versions de ce document.</a></h2>
<p>Les nouvelles version du Serial-Programming-HOWTO seront
disponibles à<br>
<code><a href=
"ftp://sunsite.unc.edu:/pub/Linux/docs/HOWTO/Serial-Programming-HOWTO">
ftp://sunsite.unc.edu:/pub/Linux/docs/HOWTO/Serial-Programming-HOWTO</a></code>
et les sites miroir, comme par exemple <code><a href=
"ftp://ftp.lip6.fr/pub/linux/docs/HOWTO/Serial-Programming-HOWTO">ftp://ftp.lip6.fr/pub/linux/docs/HOWTO/Serial-Programming-HOWTO</a></code>.
Il existe sous d'autres formats, comme PostScript ou DVI dans le
sous répertoire <code>other-formats</code>. Le
Serial-Programming-HOWTO est également disponible sur
<code><a href=
"http://sunsite.unc.edu/LDP/HOWTO/Serial-Programming-HOWTO.html">http://sunsite.unc.edu/LDP/HOWTO/Serial-Programming-HOWTO.html</a></code>,
et sera posté dans <code><a href=
"news:comp.os.linux.answers">comp.os.linux.answers</a></code> tous
les mois (NdT : la version française de ce document est
également postée dans <code><a href=
"news:fr.comp.os.linux.annonce">fr.comp.os.linux.annonce</a></code>
tous les mois).</p>
<h2><a name="ss1.3">1.3 Commentaires</a></h2>
<p>Envoyez moi, s'il vous plaît toute correction, question,
commentaire, suggestion ou complément. Je désire
améliorer cet HOWTO ! Dites moi exactement ce que vous
ne comprenez pas, ou ce qui pourrait être plus clair. Vous
pouvez me contacter à <code><a href=
"mailto:Peter.Baumann@dlr.de">Peter.Baumann@dlr.de</a></code> par
courrier électronique. Veuillez inclure le numéro de
version de ce document pour tout courrier. Ce document est la
version 0.3.</p>
<h2><a name="s2">2. Démarrage</a></h2>
<h2><a name="ss2.1">2.1 Débuggage</a></h2>
<p>Le meilleur moyen de débugguer votre code est d'installer
une autre machine sous Linux et de connecter les deux ordinateurs
par un câble null-modem. Utilisez <code>miniterm</code>
(disponible dans le Linux programmers guide --
<code>ftp://sunsite.unc.edu/pub/Linux/docs/LDP/programmers-guide/lpg-0.4.tar.gz</code>
-- dans le répertoire des exemples) pour transmettre des
caractères à votre machine Linux.
<code>Miniterm</code> est très simple à compiler et
transmettra toute entrée clavier directement sur le port
série. Vous n'avez qu'à adapter la commande
<code>#define MODEMDEVICE "/dev/ttyS0"</code> à vos besoins.
Mettez <code>ttyS0</code> pour COM1, <code>ttyS1</code> for COM2,
etc... Il est essentiel, pour les tests, que <em>tous</em> les
caractères soient transmis bruts (sans traitements) au
travers de la ligne série. Pour tester votre connexion,
démarrez <code>miniterm</code> sur les deux ordinateurs et
taper au clavier. Les caractères écrit sur un
ordinateur devraient apparaître sur l'autre ordinateur, et
vice versa. L'entrée clavier sera également
recopiée sur l'écran de l'ordinateur local.</p>
<p>Pour fabriquer un câble null-modem, pour devez croiser les
lignes TxD (<em>transmit</em>) et RxD (<em>receive</em>). Pour une
description du câble, référez vous à la
section 7 du Serial-HOWTO.</p>
<p>Il est également possible de faire cet essai avec
uniquement un seul ordinateur, si vous disposez de deux ports
série. Vous pouvez lancez deux <code>miniterm</code>s sur
deux consoles virtuelles. Si vous libérez un port
série en déconnectant la souris, n'oubliez pas de
rediriger <code>/dev/mouse</code> si ce fichier existe. Si vous
utilisez une carte série à ports multiples, soyez
sûr de la configurer correctement. La mienne n'était
pas correctement configurée, et tout fonctionnait
correctement lorsque je testais sur mon ordinateur. Lorsque je l'ai
connecté à un autre, le port a commencé
à perdre des caractères. L'exécution de deux
programmes sur un seul ordinateur n'est pas totalement
asynchrone.</p>
<h2><a name="ss2.2">2.2 Configuration des ports</a></h2>
<p>Les périphériques <code>/dev/ttyS*</code> sont
destinés à connecter les terminaux à votre
machine Linux, et sont configurés pour cet usage
après le démarrage. Vous devez vous en souvenir
lorsque vous programmez la communication avec un
périphérique autre. Par exemple, les ports sont
configurés pour afficher les caractères
envoyés vers lui-même, ce qui normalement doit
être changé pour la transmission de
données.</p>
<p>Tous les paramètres peuvent être facilement
configuré depuis un programme. La configuration est
stockée dans une structure de type <code>struct
termios</code>, qui est définie dans
<code><asm/termbits.h></code> :</p>
<blockquote>
<pre>
<code>#define NCCS 19
struct termios {
tcflag_t c_iflag; /* Modes d'entrée */
tcflag_t c_oflag; /* Modes de sortie */
tcflag_t c_cflag; /* Modes de contrôle */
tcflag_t c_lflag; /* Modes locaux */
cc_t c_line; /* Discipline de ligne */
cc_t c_cc[NCCS]; /* Caractères de contrôle */
};
</code>
</pre></blockquote>
<p>Ce fichier inclus également la définition des
constantes. Tous les modes d'entrée dans
<code>c_iflag</code> prennent en charge le traitement de
l'entrée, ce qui signifie que les caractères
envoyés depuis le périphérique peuvent
être traités avant d'être lu par
<code>read</code>. De la même façon,
<code>c_oflags</code> se chargent du traitement en sortie.
<code>c_cflag</code> contient les paramètres du port, comme
la vitesse, le nombre de bits par caractère, les bits
d'arrêt, etc... Les modes locaux, stockés dans
<code>c_lflag</code> déterminent si les caractères
sont imprimés, si des signaux sont envoyés à
votre programme, etc... Enfin, le tableau <code>c_cc</code>
définit les caractères de contrôle pour la fin
de fichier, le caractère stop, etc... Les valeurs par
défaut pour les caractères de contrôle sont
définies dans <code><asm/termios.h></code>. Les modes
possibles sont décrits dans la page de manuel de
<code>termios(3)</code>. La structure <code>termios</code> contient
un champ <code>c_line</code> (discipline de ligne), qui n'est pas
utilisé sur les systèmes conformes à
POSIX.</p>
<h2><a name="ss2.3">2.3 Façons de lire sur les
périphériques série</a></h2>
<p>Voici trois façons de lire sur les
périphériques série. Le moyen approprié
doit être choisi pour chaque application. Lorsque cela est
possible, ne lisez pas les chaînes caractère par
caractère. Lorsque j'utilisais ce moyen, je perdais des
caractères, alors qu'un <code>read</code> sur la
chaîne complète ne donnait aucune erreur.</p>
<h3>Entrée canonique</h3>
<p>C'est le mode de fonctionnement normal pour les terminaux, mais
peut également être utilisé pour communiquer
avec d'autres périphériques. Toutes les
entrées sont traitées lignes par lignes, ce qui
signifie qu'un <code>read</code> ne renverra qu'une ligne
complète. Une ligne est terminée par défaut
avec un caractère <code>NL</code> (ACII <code>LF</code>),
une fin de fichier, ou un caractère de fin de ligne. Un
<code>CR</code> (le caractère de fin de ligne par
défaut de DOS et Windows) ne terminera pas une ligne, avec
les paramètres par défaut.</p>
<p>L'entrée canonique peut également prendre en
charge le caractère erase, d'effacement de mot, et de
réaffichage, la traduction de <code>CR</code> vers
<code>NL</code>, etc...</p>
<h3>Entrée non canonique</h3>
<p>L'entrée non canonique va prendre en charge un nombre
fixé de caractère par lecture, et autorise
l'utilisation d'un compteur de temps pour les caractères. Ce
mode doit être utilisé si votre application lira
toujours un nombre fixé de caractères, ou si le
périphérique connecté envoit les
caractères par paquet.</p>
<h3>Entrée asynchrone</h3>
<p>Les deux modes ci-dessus peut être utilisé en mode
synchrone ou asynchrone. Le mode synchrone est le mode par
défaut, pour lequel un appel à <code>read</code> sera
bloquant, jusqu'à ce que la lecture soit satisfaite. En mode
asynchrone, un appel à <code>read</code> retournera
immédiatement et lancera un signal au programme appelant en
fin de transfert. Ce signal peut être reçu par un
gestionnaire de signal.</p>
<h3>Attente d'entrée depuis de multiples sources</h3>
<p>Cela ne constitue pas un mode d'entrée différent,
mais peut s'avérer être utile, si vous prenez en
charge des périphériques multiples. Dans mon
application, je traitais l'entrée depuis une socket TCP/IP
et depuis une connexion série sur un autre ordinateur
quasiment en même temps. L'exemple de programme donné
plus loin attendra des caractères en entrée depuis
deux sources. Si des données sur l'une des sources
deviennent disponibles, elles seront traitées, et le
programme attendra de nouvelles données.</p>
<p>L'approche présentée plus loin semble plutôt
complexe, mais il est important que vous vous rappeliez que Linux
est un système multi-tâche. L'appel système
<code>select</code> ne charge pas le processeur lorsqu'il attend
des données, alors que le fait de faire une boucle
jusqu'à ce que des caractères deviennent disponibles
ralentirait les autres processus.</p>
<h2><a name="s3">3. Exemples de programmes</a></h2>
<p>Tous les exemples ont été extraits de
<code>miniterm.c</code>. Le tampon d'entrée est
limité à 255 caractères, tout comme l'est la
longueur maximale d'une ligne en mode canonique
(<code><linux/limits.h></code> ou
<code><posix1_lim.h></code>).</p>
<p>Référez-vous aux commentaires dans le code source
pour l'explication des différents modes d'entrée.
J'espère que le code est compréhensible. L'exemple
sur l'entrée canonique est la plus commentée, les
autres exemples sont commentés uniquement lorsqu'ils
diffèrent, afin de signaler les différences.</p>
<p>Les descriptions ne sont pas complètes, mais je vous
encourage à modifier les exemples pour obtenir la solution
la plus intéressante pour votre application.</p>
<p>N'oubliez pas de donner les droits corrects aux ports
série (par exemple, <code>chmod a+rw
/dev/ttyS1</code>) !</p>
<h2><a name="ss3.1">3.1 Traitement canonique</a></h2>
<blockquote>
<pre>
<code>#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
/* les valeurs pour la vitesse, baudrate, sont définies dans <asm/termbits.h>, qui est inclus
dans <termios.h> */
#define BAUDRATE B38400
/* changez cette définition pour utiliser le port correct */
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme à POSIX */
#define FALSE 0
#define TRUE 1
volatile int STOP=FALSE;
main()
{
int fd,c, res;
struct termios oldtio,newtio;
char buf[255];
/*
On ouvre le périphérique du modem en lecture/écriture, et pas comme
terminal de contrôle, puisque nous ne voulons pas être terminé si l'on
reçoit un caractère CTRL-C.
*/
fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY );
if (fd <0) {perror(MODEMDEVICE); exit(-1); }
tcgetattr(fd,&oldtio); /* sauvegarde de la configuration courante */
bzero(&newtio, sizeof(newtio)); /* on initialise la structure à zéro */
/*
BAUDRATE: Affecte la vitesse. vous pouvez également utiliser cfsetispeed
et cfsetospeed.
CRTSCTS : contrôle de flux matériel (uniquement utilisé si le câble a
les lignes nécessaires. Voir la section 7 du Serial-HOWTO).
CS8 : 8n1 (8 bits,sans parité, 1 bit d'arrêt)
CLOCAL : connexion locale, pas de contrôle par le modem
CREAD : permet la réception des caractères
*/
newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
/*
IGNPAR : ignore les octets ayant une erreur de parité.
ICRNL : transforme CR en NL (sinon un CR de l'autre côté de la ligne
ne terminera pas l'entrée).
sinon, utiliser l'entrée sans traitement (device en mode raw).
*/
newtio.c_iflag = IGNPAR | ICRNL;
/*
Sortie sans traitement (raw).
*/
newtio.c_oflag = 0;
/*
ICANON : active l'entrée en mode canonique
désactive toute fonctionnalité d'echo, et n'envoit pas de signal au
programme appelant.
*/
newtio.c_lflag = ICANON;
/*
initialise les caractères de contrôle.
les valeurs par défaut peuvent être trouvées dans
/usr/include/termios.h, et sont données dans les commentaires.
Elles sont inutiles ici.
*/
newtio.c_cc[VINTR] = 0; /* Ctrl-c */
newtio.c_cc[VQUIT] = 0; /* Ctrl-\ */
newtio.c_cc[VERASE] = 0; /* del */
newtio.c_cc[VKILL] = 0; /* @ */
newtio.c_cc[VEOF] = 4; /* Ctrl-d */
newtio.c_cc[VTIME] = 0; /* compteur inter-caractère non utilisé */
newtio.c_cc[VMIN] = 1; /* read bloquant jusqu'à l'arrivée d'1 caractère */
newtio.c_cc[VSWTC] = 0; /* '\0' */
newtio.c_cc[VSTART] = 0; /* Ctrl-q */
newtio.c_cc[VSTOP] = 0; /* Ctrl-s */
newtio.c_cc[VSUSP] = 0; /* Ctrl-z */
newtio.c_cc[VEOL] = 0; /* '\0' */
newtio.c_cc[VREPRINT] = 0; /* Ctrl-r */
newtio.c_cc[VDISCARD] = 0; /* Ctrl-u */
newtio.c_cc[VWERASE] = 0; /* Ctrl-w */
newtio.c_cc[VLNEXT] = 0; /* Ctrl-v */
newtio.c_cc[VEOL2] = 0; /* '\0' */
/*
à présent, on vide la ligne du modem, et on active la configuration
pour le port
*/
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);
/*
la configuration du terminal est faite, à présent on traite
les entrées
Dans cet exemple, la réception d'un 'z' en début de ligne mettra
fin au programme.
*/
while (STOP==FALSE) { /* boucle jusqu'à condition de terminaison */
/* read bloque l'exécution du programme jusqu'à ce qu'un caractère de
fin de ligne soit lu, même si plus de 255 caractères sont saisis.
Si le nombre de caractères lus est inférieur au nombre de caractères
disponibles, des read suivant retourneront les caractères restants.
res sera positionné au nombre de caractères effectivement lus */
res = read(fd,buf,255);
buf[res]=0; /* on termine la ligne, pour pouvoir l'afficher */
printf(":%s:%d\n", buf, res);
if (buf[0]=='z') STOP=TRUE;
}
/* restaure les anciens paramètres du port */
tcsetattr(fd,TCSANOW,&oldtio);
}
</code>
</pre></blockquote>
<h2><a name="ss3.2">3.2 Entrée non canonique</a></h2>
<p>Dans le mode non canonique, les caractères lus ne sont
pas assemblés ligne par ligne, et ils ne subissent pas de
traitement (erase, kill, delete, etc...). Deux paramètres
contrôlent ce mode : <code>c_cc[VTIME]</code> positionne
le <em>timer</em> de caractères, et <code>c_cc[VMIN]</code>
indique le nombre minimum de caractères à recevoir
avant qu'une lecture soit satisfaite.</p>
<p>Si MIN > 0 et TIME = 0, MIN indique le nombre de
caractères à recevoir avant que la lecture soit
satisfaite. TIME est égal à zéro, et le
<em>timer</em> n'est pas utilisé.</p>
<p>Si MIN = 0 et TIME > 0, TIME est utilisé comme une
valeur de <em>timeout</em>. Une lecture est satisfaite lorsqu'un
caractère est reçu, ou que la durée TIME est
dépassée (t = TIME * 0.1s). Si TIME est
dépassé, aucun caractère n'est
retourné.</p>
<p>Si MIN > 0 et TIME > 0, TIME est employé comme
<em>timer</em> entre chaque caractère. La lecture sera
satisfaite si MIN caractères sont reçus, ou que le
<em>timer</em> entre deux caractères dépasse TIME. Le
<em>timer</em> est réinitialisé à chaque fois
qu'un caractère est reçu, et n'est activé
qu'après la réception du premier
caractère.</p>
<p>Si MIN = 0 et TIME = 0, le retour est immédiat. Le nombre
de caractères disponibles, ou bien le nombre de
caractères demandé est retourné. Selon
Antonino (voir le paragraphe sur les participations), vous pouvez
utiliser un <code>fcntl(fd, F_SETFL, FNDELAY);</code> avant la
lecture pour obtenir le même résultat.</p>
<p>Vous pouvez tester tous les modes décrit ci-dessus en
modifiant <code>newtio.c_cc[VTIME]</code> et
<code>newtio.c_cc[VMIN]</code>.</p>
<blockquote>
<pre>
<code>#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <stdio.h>
#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme à POSIX */
#define FALSE 0
#define TRUE 1
volatile int STOP=FALSE;
main()
{
int fd,c, res;
struct termios oldtio,newtio;
char buf[255];
fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY );
if (fd <0) {perror(MODEMDEVICE); exit(-1); }
tcgetattr(fd,&oldtio); /* sauvegarde de la configuration courante */
bzero(&newtio, sizeof(newtio));
newtio.c_cflag = BAUDRATE | CRTSCTS | CS8 | CLOCAL | CREAD;
newtio.c_iflag = IGNPAR;
newtio.c_oflag = 0;
/* positionne le mode de lecture (non canonique, sans echo, ...) */
newtio.c_lflag = 0;
newtio.c_cc[VTIME] = 0; /* timer inter-caractères non utilisé */
newtio.c_cc[VMIN] = 5; /* read bloquant jusqu'à ce que 5 */
/* caractères soient lus */
tcflush(fd, TCIFLUSH);
tcsetattr(fd,TCSANOW,&newtio);
while (STOP==FALSE) { /* boucle de lecture */
res = read(fd,buf,255); /* retourne après lecture 5 caractères */
buf[res]=0; /* pour pouvoir les imprimer... */
printf(":%s:%d\n", buf, res);
if (buf[0]=='z') STOP=TRUE;
}
tcsetattr(fd,TCSANOW,&oldtio);
}
</code>
</pre></blockquote>
<h2><a name="ss3.3">3.3 Lecture asynchrone</a></h2>
<blockquote>
<pre>
<code>#include <termios.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/signal.h>
#include <sys/types.h>
#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS1"
#define _POSIX_SOURCE 1 /* code source conforme à POSIX */
#define FALSE 0
#define TRUE 1
volatile int STOP=FALSE;
void signal_handler_IO (int status); /* le gestionnaire de signal */
int wait_flag=TRUE; /* TRUE tant que reçu aucun signal */
main()
{
int fd,c, res;
struct termios oldtio,newtio;
struct sigaction saio; /* définition de l'action du signal */
char buf[255];
/* ouvre le port en mon non-bloquant (read retourne immédiatement) */
fd = open(MODEMDEVICE, O_RDWR | O_NOCTTY | O_NONBLOCK);
if (fd <0) {perror(MODEMDEVICE); exit(-1); }
/* installe le gestionnaire de signal avant de passer le port en
mode asynchrone */
saio.sa_handler = signal_handler_IO;
saio.sa_mask = 0;
saio.sa_flags = 0;
saio.sa_restorer = NULL;
sigaction(SIGIO,&saio,NULL);
/* permet au processus de recevoir un SIGIO */
fcntl(fd, F_SETOWN, getpid());
/* rend le descripteur de fichier asynchrone (la page de manuel
indique que seuls O_APPEND et O_NONBLOCK fonctionnent avec
F_SETFL...) */
fcntl(fd, F_SETFL, FASYNC);
tcgetattr(fd,&oldtio); /* sauvegarde de la configuration courante */
/* positionne les nouvelles valeurs pour lecture canonique */
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);
/* on boucle en attente de lecture. généralement, on réalise
des traitements à l'intérieur de la boucle */
while (STOP==FALSE) {
printf(".\n");usleep(100000);
/* wait_flag = FALSE après réception de SIGIO. Des données sont
disponibles et peuvent être lues */
if (wait_flag==FALSE) {
res = read(fd,buf,255);
buf[res]=0;
printf(":%s:%d\n", buf, res);
if (res==1) STOP=TRUE; /* on arrête la boucle si on lit une
ligne seule */
wait_flag = TRUE; /* on attend de nouvelles données */
}
}
/* restaure les anciens paramètres du port */
tcsetattr(fd,TCSANOW,&oldtio);
}
/***************************************************************************
* gestionnaire de signal. Positionne wait_flag à FALSE, pour indiquer à *
* la boucle ci-dessus que des caractères ont été reçus. *
***************************************************************************/
void signal_handler_IO (int status)
{
printf("réception du signal SIGIO.\n);
wait_flag = FALSE;
}
</code>
</pre></blockquote>
<h2><a name="ss3.4">3.4 Multiplexage en lecture</a></h2>
<p>Cette section est réduite au minimum, et n'est là
que pour vous guider. Le code source d'exemple
présenté est donc réduit au strict minimum. Il
ne fonctionnera pas seulement avec des ports série, mais
avec n'importe quel ensemble de descripteurs de fichiers.</p>
<p>L'appel système select et les macros qui lui sont
attachées utilisent un <code>fd_set</code>. C'est un tableau
de bits, qui dispose d'un bit pour chaque descripteur de fichier
valide. <code>select</code> accepte un <code>fd_set</code> ayant
les bits positionnés pour les descripteurs de fichiers qui
conviennent, et retourne un <code>fd_set</code>, dans lequel les
bits des descripteurs de fichier où une lecture, une
écriture ou une exception sont positionnés. Toutes
les manipulations de <code>fd_set</code> sont faites avec les
macros fournies. Reportez vous également à la page de
manuel de <code>select(2)</code>.</p>
<blockquote>
<pre>
<code>#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
main()
{
int fd1, fd2; /* entrées 1 et 2 */
fd_set readfs; /* ensemble de descripteurs */
int maxfd; /* nombre max des descripteurs utilisés */
int loop=1; /* boucle tant que TRUE */
/* open_input_source ouvre un périphérique, configure le port
correctement, et retourne un descripteur de fichier. */
fd1 = open_input_source("/dev/ttyS1"); /* COM2 */
if (fd1<0) exit(0);
fd2 = open_input_source("/dev/ttyS2"); /* COM3 */
if (fd2<0) exit(0);
maxfd = MAX (fd1, fd2)+1; /* numéro maximum du bit à tester */
/* boucle d'entrée */
while (loop) {
FD_SET(fd1, &readfs); /* test pour la source 1 */
FD_SET(fd2, &readfs); /* test pour la source 2 */
/* on bloque jusqu'à ce que des caractères soient
disponibles en lecture */
select(maxfd, &readfs, NULL, NULL, NULL);
if (FD_ISSET(fd1)) /* caractères sur 1 */
handle_input_from_source1();
if (FD_ISSET(fd2)) /* caractères sur 2 */
handle_input_from_source2();
}
}
</code>
</pre></blockquote>
<p>L'exemple ci-dessus bloque indéfiniment, jusqu'à
ce que des caractères venant d'une des sources soient
disponibles. Si vous avez besoin d'un <em>timeout</em>, remplacez
juste l'appel à select par :</p>
<blockquote>
<pre>
<code>int res;
struct timeval Timeout;
/* fixe la valeur du timeout */
Timeout.tv_usec = 0; /* millisecondes */
Timeout.tv_sec = 1; /* secondes */
res = select(maxfd, &readfs, NULL, NULL, &Timeout);
if (res==0)
/* nombre de descripteurs de fichiers avec caractères
disponibles = 0, il y a eu timeout */
</code>
</pre></blockquote>
<p>Cet exemple verra l'expiration du delai de <em>timeout</em>
après une seconde. S'il y a <em>timeout</em>, select
retournera 0, mais faîtes attention, <code>Timeout</code> est
décrémenté du temps réellement attendu
par <code>select</code>. Si la valeur de <em>timeout</em> est 0,
select retournera immédiatement.</p>
<h2><a name="s4">4. Autres sources d'information</a></h2>
<ul>
<li>Le Linux Serial-HOWTO décrit comment mettre en place les
ports série et contient des informations sur le
matériel.</li>
<li>Le <a href="http://www.easysw.com/~mike/serial">Serial
Programming Guide for POSIX Compliant Operating Systems</a>, par
Michael Sweet. Ce lien est périmé et je n'arrive pas
à trouver la nouvelle adresse du document. Quelqu'un sait-il
où je peux le retrouver ? C'était un très
bon document !</li>
<li>La page de manuel de <code>termios(3)</code> décrit
toutes les constantes utilisées pour la structure
<code>termios</code>.</li>
</ul>
<h2><a name="s5">5. Contributions</a></h2>
<p>Comme je l'ai dit dans l'introduction, je ne suis pas un expert
dans le domaine, mais j'ai rencontré des problèmes,
et j'ai trouvé les solutions avec l'aide d'autres personnes.
Je tiens à remercier pour leur aide M. Strudthoff du
European Transonic WindTunnel, Cologne, Michael Carter
(<code>mcarter@rocke.electro.swri.edu</code>) et Peter Waltenberg
(<code>p.waltenberg@karaka.chch.cri.nz</code>).</p>
<p>Antonino Ianella (<code>antonino@usa.net</code> a écrit
le Serial-Port-Programming Mini HOWTO, au même moment
où je préparais ce document. Greg Hankins m'a
demandé d'inclure le Mini-HOWTO d'Antonino dans ce
document.</p>
<p>La structure de ce document et le formattage SGML ont
été dérivés du Serial-HOWTO de Greg
Hankins. Merci également pour diverses corrections faites
par : Dave Pfaltzgraff
(<code>Dave_Pfaltzgraff@patapsco.com</code>), Sean Lincolne
(<code>slincol@tpgi.com.au</code>), Michael Wiedmann
(<code>mw@miwie.in-berlin.de</code>), et Adrey Bonar
(<code>andy@tipas.lt</code>).</p>
</body>
</html>
|