ttyXXX

Outils pour communiquer:

• putty

• minicom

[21737.134917] usb 3-3: new full-speed USB device number 9 using xhci_hcd

[21737.285646] usb 3-3: New USB device found, idVendor=2341, idProduct=0043

[21737.285651] usb 3-3: New USB device strings: Mfr=1, Product=2, SerialNumber=220

[21737.285654] usb 3-3: Manufacturer: Arduino (www.arduino.cc)

[21737.285657] usb 3-3: SerialNumber: 9533335383635130D0B1

[21737.334214] cdc_acm 3-3:1.0: ttyACM0: USB ACM device

[21737.334613] usbcore: registered new interface driver cdc_acm

[21737.334615] cdc_acm: USB Abstract Control Model driver for USB modems and ISDN adapters

work@bruno:~$ 

Exemple d’émission

/* serial.c

   Confguration de la voie serie a 4800 bps.

   Configuration de la carte série :

   - Entete actif.

   - Checksum inactif.

   - Envoi en continu

   Ce programme affiche en continu les états de pot1, pot2 et du bouton poussoir.

   */

#include <stdio.h>

#include <stdlib.h>

#include <termios.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

typedef struct {

  unsigned char pot1;

 unsigned char pot2;

 unsigned char bouton;

} trame ;

int main (int argc, char **argv)

{

 trame t;

 int fd;

 unsigned char in;

 struct termios termios_p;

 fd = open("/dev/ttyS0", O_RDWR);

 if ( fd == -1 )

 {

  perror("Impossible d'obtenir le descripteur de fichier !");

  return EXIT_FAILURE;

 }

 /* Configuration du port serie */

 tcgetattr(fd, &termios_p);

 cfmakeraw(&termios_p);

 termios_p.c_lflag &= ~ICANON;

 cfsetispeed( &termios_p, B4800);

 cfsetospeed( &termios_p, B4800);

 tcsetattr(fd, TCSANOW, &termios_p);

 do

 { 

  /* Boucle permettant d'attendre l'en-tete */

  do

  {

   read(fd, &in, 1);

  } while ( in != 255 );

  read(fd, &t.pot1, 1);

  read(fd, &t.pot2, 1);

  read(fd, &t.bouton, 1);

  printf("Pot1 = %3u\tPot2 = %3u\tBouton = %u\n", t.pot1, t.pot2, t.bouton);

 } while (1); /* Boucle infinie */

}

Réception en C , exemple

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <termios.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

/* les valeurs pour la vitesse, baudrate, sont définies dans <asm/termbits.h>, qui est inclus

dans <termios.h> */

#define BAUDRATE B9600            

/* changez cette définition pour utiliser le port correct */

#define MODEMDEVICE "/dev/ttyACM0"

#define _POSIX_SOURCE 1 /* code source conforme à POSIX */

#define FALSE 0

#define TRUE 1

volatile int STOP=FALSE; 

int main(int argc,char **argv)

{

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

  printf("%s",buf);

    if (buf[0]=='z') STOP=TRUE;

 }

 /* restaure les anciens paramètres du port */

 tcsetattr(fd,TCSANOW,&oldtio);

}

/* envoi d'un A */ 

#include <stdio.h>

#include <stdlib.h>

#include <termios.h>

#include <unistd.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdint.h>

#include <stdbool.h>

#define BAUDRATE B9600

#define terminal "/dev/ttyACM0"

int main ()

{

   int fd = 0;

   bool return_code = true;

   fd = open(terminal, O_RDWR);

   if (fd != -1)

   {

      struct termios newtio = {0}, oldtio = {0};

      speed_t speed = {0};

      uint8_t marker = 0xff;

      tcgetattr(fd, &oldtio);

      newtio = oldtio;

      cfsetospeed(&newtio, BAUDRATE);

      cfsetispeed(&newtio, BAUDRATE);

      /* cfmakeraw(&newtio); */

      tcsetattr(fd, TCSANOW, &newtio);

      write (fd,"A",1);

/* -- -- */

      speed = cfgetospeed(&newtio);

      tcsetattr(fd, TCSANOW, &oldtio);

      close(fd);

   }

   else

   {

      perror("Erreur ");

   }

   return EXIT_SUCCESS;

}

https://tutox.fr/2018/02/02/communiquer-port-serie-linux/

Excellent site  sur le sujet :

http://pficheux.free.fr/articles/lmf/serial/