Sujet Précédent Sujet Suivant

Communication - PC <=> Arduino - par USB

Résolu/Fermé
Michel_pc4 Messages postés 5 Date d'inscription samedi 1 janvier 2022 Statut Membre Dernière intervention 11 janvier 2022 - 1 janv. 2022 à 21:21
Michel_pc4 Messages postés 5 Date d'inscription samedi 1 janvier 2022 Statut Membre Dernière intervention 11 janvier 2022 - 3 janv. 2022 à 17:32
Bonjour,

J'ai cherché depuis plusieurs jours du code en langage C pour communiquer avec une carte Arduino UNO smraza. Avec de la patience, j'ai réussis une partie du devis.

En effet, je réussi a envoyer des caractères à la carte par USB. Toutefois, je ne réussis pas à recevoir la réponse de la carte Arduino. Je sais avec certitude que la carte Arduino a reçu la commande par le message qu'elle affiche sur le petit LCD que j'y ai branché. Et du côté de ce microcontrôleur, les commandes pour lire et écrire sur le port USB sont assez simple genre : 


Serial.println("toto");
String r;
r = Serial.readString;


Ce n'est qu'a la fin du code, ou il y a le "read" que cela flanche ...

Soyez indulgent, mes connaissances en C sont très limité, j'ai passé les 10 dernières années à développer de l'AOS en VB.NET.

Voici mon code reconstitué tant bien que mal : 

// Linux Mint 20.1 - Code::Blocks.
//
// Au début ce n'est qu'un jeu de caractères pour garder le contrôle au clavier
// Deux entrées similaires successive et le programme continue, ex. : a a , b b , etc ...
// Deux entrées différente successive et le programme arrête, ex. : a  b
//
// Pour donner les droits ajouter l'utilisateur à DIALOUT
//  sudo adduser $USER dialout
//
//----------------------------------
// C - Librairie d'entête
#include <stdio.h>      // Definition des entrés et sorties standard
#include <stdlib.h>
#include <string.h>     // Definition des chaines de caracteres

#include <unistd.h>     // Definition des fonctions standard de UNIX
#include <fcntl.h>      // Contient les constantes de contrôle de fichier ex.: O_RDWR
#include <errno.h>      // Erreur integer Et strerror() function
#include <termios.h>    // Contient les définitions de contrôle pour le terminal POSIX

#define Taille 256

// Variable du port USB
int PortUSBUno;
struct termios tty, old_tio, new_tio;

// Variable de saisie au clavier
char strEntree[256]="1";
char strCmd[256]="1";
char strAncCmd[256]="1";
char strReponse[256]="1";
char strSimul[256]="1";

//char * lecteur ;
char * lecturelocal;           // Variable de lecture au clavier

char lecture[Taille];   // Variable tampon d'entrée pour le port USB
char * mot;
int reslec;             // Variable témoin d'entrée pour le port USB
int reswrt;             // Variable témoin de sortie pour le port USB

char x;

void setup()
{
    // Obtenir les paramètres du terminal pour stdin
    tcgetattr(STDIN_FILENO,&old_tio);
    new_tio = old_tio;
    // Désactivation du mode canonique (entrées/sorties en mémoire tampon) et de l'écho local.
    new_tio.c_lflag &=(~ICANON & ~ECHO);
    tcsetattr(STDIN_FILENO,TCSANOW,&new_tio);

    // Initialise l'espace mémoire nécessaire au port USB
    memset (&tty, 0, sizeof tty);
    // Ouverture du port
    PortUSBUno = open( "/dev/ttyACM0", O_RDWR| O_NONBLOCK | O_NDELAY );
    // Si erreur
    if ( PortUSBUno < 0 )
    {
        // Affichage de lerreur
        printf("Erreur %d a louverture du port /dev/ttyACM0.\n", errno);
    }
    else
    {
        // Afficher un message de continuité
        printf("Port USB ouvert correctement.\n");
    }

    if ( tcgetattr ( PortUSBUno, &tty ) != 0 )
    {
        printf("Erreur [%d] en provenance de tcgetattr : [%s].\n", errno, strerror(errno));
    }
    else
    {
        // Afficher un message de continuité
        printf("Pas de probleme avec tcgetattr.\n");
    }

    printf("Ligne 67 ispeed = %d; ospeed = %d flags = %o, %o, %o %d %d\n", cfgetispeed(&tty), cfgetospeed(&tty), tty.c_cflag, tty.c_lflag, tty.c_oflag, tty.c_cc[VMIN], tty.c_cc[VTIME]);

    // Configure les vitesses entrée/sortie
    //cfsetospeed (&tty, (speed_t)28800); // Configure la vitesse en sortie
    //cfsetispeed (&tty, (speed_t)28800); // Configure la vitesse en entrée
    //cfsetospeed (&tty, B9600); // Configure la vitesse en sortie
    //cfsetispeed (&tty, B9600); // Configure la vitesse en entrée
    cfsetspeed (&tty, B9600); // Configure la vitesse en entrée

    printf("Ligne 75 ispeed = %d; ospeed = %d flags = %o, %o, %o %d %d\n", cfgetispeed(&tty), cfgetospeed(&tty), tty.c_cflag, tty.c_lflag, tty.c_oflag, tty.c_cc[VMIN], tty.c_cc[VTIME]);

    // Réglage d'autres éléments du port
    tty.c_cflag     &=  ~PARENB;        // Pas de bit de parité
    tty.c_cflag     &=  ~CSTOPB;        // Seulement besoin 1 stop bit
    tty.c_cflag     &=  ~CSIZE;
    tty.c_cflag     |=  CS8;            // Caractere de 8 bits
    tty.c_cflag     &=  ~CRTSCTS;       // Pas de contrôle de flux du matériel

    // Pas de mode canonique
    tty.c_cflag     |=  CREAD | CLOCAL; // Activer READ et ignorer les lignes de contrôlel
    tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
    tty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
//    tty.c_lflag     =   0;              // Pas de caracteres de signilisation, pas décho, pas de traitement canonique
    tty.c_oflag &= ~OPOST;
//    tty.c_oflag     =   0;              // Pas de remappage, pas de délai

    // Récupérer les octets dès qu'ils sont disponibles
    tty.c_cc[VMIN]  =   0;              // La lecture ne block pas
    tty.c_cc[VTIME] =   5;              // 0.5 seconds de délai de lecture "timeout"

//    tty.c_iflag     &=  ~(IXON | IXOFF | IXANY);          // Désactiver le contrôle du flux s/w
//    tty.c_lflag     &=  ~(ICANON | ECHO | ECHOE | ISIG);  // Mise à zéro
//    tty.c_oflag     &=  ~OPOST;                           // Mise à zéro

    // Réinitialise le port USB et applique les attributs
    tcflush( PortUSBUno, TCIFLUSH );


    // Si erreur
    if ( tcsetattr ( PortUSBUno, TCSANOW, &tty ) != 0)
    {
        printf("Erreur %d de transmission/reception tcsetattr.\n", errno);
    }
    else
    {
        // Afficher un message de continuité - TC SET ATTRIBUT
        printf("Pas de probleme avec tcsetattr.\n");
    }

    // Affiche la situation
    printf("Ligne 107 ispeed = %d; ospeed = %d flags = %o, %o, %o %d %d\n", cfgetispeed(&tty), cfgetospeed(&tty), tty.c_cflag, tty.c_lflag, tty.c_oflag, tty.c_cc[VMIN], tty.c_cc[VTIME]);
}


int main ()
{

    // Initialisation
    setup();
    printf("Initialisation termine.\n");

    printf("La commande n-1 est [%s].\n",strAncCmd);
    printf("La commande en cours est [%s].\n",strCmd);
    printf("La simulation en cours est [%s].\n",strSimul);
    printf("\n\n");

    while (strcmp(strSimul,strCmd) == 0)
    {
        printf("Entrez la commande à recevoir : ");
        lecturelocal = fgets(strEntree,9,stdin);
        strncpy(strCmd, strEntree, strlen(strEntree)-1);
        printf("La commande est : [%s].\n", strCmd);

        printf("Entrez la réponse attendu : ");
        lecturelocal = fgets(strEntree,9,stdin);
        strncpy(strSimul, strEntree, strlen(strEntree)-1);
        printf("La réponse est [%s].\n", strSimul);

        if (strcmp(strCmd,strSimul) == 0)
        {
            printf("Les deux chaînes sont égales.\n");
            lecturelocal = fgets(strEntree,9,stdin);
            strncpy(strReponse, strEntree, strlen(strEntree)-1);
        }
        else
        {
            printf("Les deux chaînes ne sont pas égales.\n");
            lecturelocal = fgets(strEntree,9,stdin);
            strncpy(strReponse, strEntree, strlen(strEntree)-1);
        }

        if (strcmp(strAncCmd,strCmd) == 0)
        {
            printf("Meme commande.\n\n");
            printf("La commande n-1 est [%s].\n",strAncCmd);
            printf("La commande en cours est [%s].\n",strCmd);
            printf("La simulation en cours est [%s].\n",strSimul);
            printf("\n");
        }
        else
        {
            printf("Commande differente.\n");
            printf("La commande n-1 est [%s].\n",strAncCmd);
            printf("La commande en cours est [%s].\n",strCmd);
            printf("La simulation en cours est [%s].\n",strSimul);
            printf("\n");
            strcpy(strAncCmd, strCmd);
        }


        // Envoie de la commande
        reswrt = write(PortUSBUno, strCmd, 1);
        // Afficher message
        printf("Commande envoyé. En attente ...\n");
        // Attente ((Nbr Car + 25) * 100) environ 100 usecondes par caractere
        usleep((1 + 25) * 100);



        // C'est ici que ça coince ...
        // Lecture de la réponse

        memset(&lecture, '\0', sizeof(lecture));

        reslec = read(PortUSBUno, &lecture, sizeof(lecture));

        if (reslec < 0)
        {
            printf("Error reading: %s", strerror(errno));
            return 1;
        }
        else
        {
            printf("MiB"); // Je n'ai pas vu ces lettres encore ...
        }
    }

    close(PortUSBUno);

    return(0);
}


Merci de votre attention
Michel


Configuration: Linux / Firefox 95.0
A voir également:

3 réponses

Réponse 1 / 3
Michel_pc4 Messages postés 5 Date d'inscription samedi 1 janvier 2022 Statut Membre Dernière intervention 11 janvier 2022
Modifié le 2 janv. 2022 à 02:23
Bonsoir,

J'ai donc continué à nettoyer ce code et j'ai avancé quelque peu.

En effet, maintenant je n'ai plus d'erreur, mais je ne reçois aucun octets.
J'ai retiré 2 paramètres à l'ouverture du port. 

//*****************************************************************************************************
// Linux Mint 20.1 - Code::Blocks 20.03
//
// Pour donner les droits ajouter l'utilisateur à DIALOUT
// sudo adduser $USER dialout
//
// Date de création     : 2022-01-01
// Date de modification : 2022-01-01
//
//*****************************************************************************************************
// C - Librairie d'entête

#include <stdio.h>      // Definition des entrés et sorties standard
#include <stdlib.h>
#include <string.h>     // Definition des chaines de caracteres

#include <unistd.h>     // Definition des fonctions standard de UNIX
#include <fcntl.h>      // Contient les constantes de contrôle de fichier ex.: O_RDWR
#include <errno.h>      // Erreur integer Et strerror() function
#include <termios.h>    // Contient les définitions de contrôle pour le terminal POSIX

#define Taille 256

// Variable du port USB
int PortUSB;
struct termios tty, old_tio, new_tio;
//struct termios2 tty;

// Variable de saisie au clavier
char strEntree[256]="1";
char strCmd[256]="1";
char strAncCmd[256]="1";
char strReponse[256]="1";
char strSimul[256]="1";
char * lecturelocal="";           // Variable local de lecture au clavier

char lecture[Taille];   // Variable tampon d'entrée pour le port USB
char * mot;
int reslec;             // Variable témoin d'entrée pour le port USB
int reswrt;             // Variable témoin de sortie pour le port USB

char x;

void setup()
{
    // Obtenir les paramètres du terminal pour stdin
    //ioctl(PortUSB, TCGETS2, &tty);
    if ( tcgetattr ( PortUSB, &tty ) == 0 )
    {
        printf("Début initialisation.\n");
        tcgetattr(PortUSB,&old_tio);
        new_tio = old_tio;

        // Initialise l'espace mémoire nécessaire au port USB
        memset (&tty, 0, sizeof tty);
        // Ouverture du port
        PortUSB = open( "/dev/ttyACM0", O_RDWR );
        // Si erreur
        if ( PortUSB == 0 )
        {
            // Réglage d'autres éléments du port
            tty.c_cflag &=  ~PARENB;        // Pas de bit de parité
            tty.c_cflag &=  ~CSTOPB;        // Seulement besoin 1 stop bit
            tty.c_cflag &=  ~CSIZE;         // Efface tous les bits du caractere
            tty.c_cflag |=  CS8;            // Caractere de 8 bits
            tty.c_cflag &=  ~CRTSCTS;       // Pas de contrôle de flux du matériel
            tty.c_lflag &= ~ICANON;         // Pas de mode canonique
            tty.c_cflag |= CREAD | CLOCAL;
            //
            tty.c_lflag &= ~ECHO;           // Désactiver l'echo
            tty.c_lflag &= ~ECHOE;          // Désactiver l'effacement
            tty.c_lflag &= ~ECHONL;         // Désactiver la nouvelle ligne de l'echo
            tty.c_lflag &= ~ISIG;           // Désactiver l'interprétation de INTR, QUIT et SUSP

            // Désactiver le contrôle du flux logiciel s/w
            tty.c_iflag &= ~( IXANY | IXON | IXOFF);
            // Désactivation du traitement spécial des octets en réception
            tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL);
            // Empêcher toute interprétation spéciale des octets de sortie
            tty.c_oflag &= ~OPOST;
            // Empêcher la conversion de la nouvelle ligne en retour de chariot/saut de ligne
            tty.c_oflag &= ~ONLCR;
            // Récupérer les octets dès qu'ils sont disponibles
            tty.c_cc[VMIN]  =   0;              // La lecture ne block pas
            tty.c_cc[VTIME] =   10;              // 1 seconde de délai de lecture "timeout"
            // Configure les vitesses entrée/sortie
            cfsetispeed (&tty, B9600); // Configure la vitesse en entrée
            cfsetospeed (&tty, B9600); // Configure la vitesse en entrée

            // Réinitialise le port USB et applique les attributs
            tcflush( PortUSB, TCIFLUSH );

            // Si erreur
            if (tcsetattr(PortUSB, TCSANOW, &tty) != 0)
            {
                printf("Error %i from tcsetattr: %s\n", errno, strerror(errno));
                return -1;
            }
        }
        else
        {
            printf("Erreur [%d] en provenance de tcgetattr : [%s].\n", errno, strerror(errno));
            return -1;
        }
    }
    else
    {
        // Affichage de lerreur
        printf("Erreur %d a louverture du port /dev/ttyACM0.\n", errno);
        return -1;
    }
}

int main ()
{
    //int boucle;
    //char b[1];
    //int i=0;
    // Initialisation
    setup();
    printf("Initialisation termine.\n\n");

    printf("La commande n-1 est [%s].\nLa commande en cours est [%s].\nLa simulation en cours est [%s].\n\n",strAncCmd,strCmd,strSimul);

    while (strcmp(strSimul,strCmd) == 0)
    {
        printf("Entrez la commande à envoyer : ");
        lecturelocal = fgets(strEntree,254,stdin);
        strncpy(strCmd, strEntree, strlen(strEntree)-1);
        printf("La commande est : [%s].\n", strCmd);

        printf("Entrez la réponse attendu : ");
        lecturelocal = fgets(strEntree,9,stdin);
        strncpy(strSimul, strEntree, strlen(strEntree)-1);
        printf("La réponse est [%s].\n", strSimul);

        if (strcmp(strCmd,strSimul) == 0)
        {
            printf("Les deux chaînes sont égales.\n");
            lecturelocal = fgets(strEntree,9,stdin);
            strncpy(strReponse, strEntree, strlen(strEntree)-1);
        }
        else
        {
            printf("Les deux chaînes ne sont pas égales.\n");
            lecturelocal = fgets(strEntree,9,stdin);
            strncpy(strReponse, strEntree, strlen(strEntree)-1);
        }

        if (strcmp(strAncCmd,strCmd) == 0)
        {
            printf("Meme commande.\n\nLa commande n-1 est [%s].\nLa commande en cours est [%s].\nLa simulation en cours est [%s].\n\n",strAncCmd,strCmd,strSimul);
        }
        else
        {
            printf("Commande differente.\n");
            printf("La commande n-1 est [%s].\n",strAncCmd);
            printf("La commande en cours est [%s].\n",strCmd);
            printf("La simulation en cours est [%s].\n",strSimul);
            printf("\n");
            strcpy(strAncCmd, strCmd);
        }

        // Envoie de la commande
        reswrt = write(PortUSB, strCmd, 1);
        // Afficher message
        printf("Commande envoyé. En attente ...\n");

        // Attente ((Nbr Car + 25) * 100) environ 100 usecondes par caractere
        usleep((1 + 25) * 1000);

        if (PortUSB < 0)
        {
            printf("Port USB insdiponible.\n");
        }
        else
        {
            printf("Port USB disponible.\n");
        }

        // Lecture de la réponse
        printf("Lecture du port : ");
        memset(&lecture, '\0', sizeof(lecture));

        reslec = read(PortUSB, &lecture, sizeof(lecture));


        if (reslec < 0)
        {
            printf("Error reading: %s.\n", strerror(errno));
        }
        else
        {
            printf("Nombre d'octets reçu : [%d]\n",reslec);
        }
    }

    close(PortUSB);

    return(0);
}


Merci de votre attention.
Michel
0
Réponse 2 / 3
Michel_pc4 Messages postés 5 Date d'inscription samedi 1 janvier 2022 Statut Membre Dernière intervention 11 janvier 2022
Modifié le 3 janv. 2022 à 03:47
Bonsoir,

Alors voilà, j'ai résolu mon problème.
J'avais des écarts des deux côtés, et j'ai nettoyé tout le programme.
Il me reste à synchroniser le tout ...

Pour ceux que ça intéresse, voici le code 

//*****************************************************************************************************
// Linux Mint 20.1 - Code::Blocks 20.03
//
// Pour donner les droits ajouter l'utilisateur à DIALOUT
// sudo adduser $USER dialout
//
// Date de création     : 2022-01-01
// Date de modification : 2022-01-01
//
// Version V102t
//
//*****************************************************************************************************
// C - Librairie d'entête

#include <stdio.h>      // Definition des entrés et sorties standard
#include <stdlib.h>
#include <string.h>     // Definition des chaines de caracteres

#include <unistd.h>     // Definition des fonctions standard de UNIX
#include <fcntl.h>      // Contient les constantes de contrôle de fichier ex.: O_RDWR
#include <errno.h>      // Erreur integer Et strerror() function
#include <termios.h>    // Contient les définitions de contrôle pour le terminal POSIX

#include <sys/ioctl.h>
#include <linux/usbdevice_fs.h>


#define Taille 256

// Variable du port USB
int PortUSB;
struct termios tty, old_tio, new_tio;

// Variable de saisie au clavier
char strCmd[256]="1";
char strReponse[256]="1";

unsigned char lecture[Taille];  // Variable tampon d'entrée pour le port USB
int reslec;                     // Variable témoin d'entrée (read) pour le port USB
int reswrt;                     // Variable témoin de sortie (write) pour le port USB
int lec;                        // Variable local de lecture au clavier
int bascule;


void setup()
{
    // Obtenir les paramètres du terminal pour stdin
    tcgetattr(STDIN_FILENO,&old_tio);
    new_tio = old_tio;

    // Initialise l'espace mémoire nécessaire au port USB
    memset (&tty, 0, sizeof tty);
    // Ouverture du port
    PortUSB = open( "/dev/ttyACM0", O_RDWR );

    // Si pas erreur
    if (!(PortUSB < 0 ))
    {
        // Obtenir les Attributs du port USB
        if ( tcgetattr ( PortUSB, &tty ) == 0 )
        {
            // Configure les vitesses entrée/sortie
            cfsetspeed (&tty, 9600); // Configure la vitesse en entrée
            // Réglage d'autres éléments du port
            tty.c_cflag &=  ~PARENB;        // Pas de bit de parité
            tty.c_cflag &=  ~CSTOPB;        // Seulement besoin 1 stop bit
            tty.c_cflag &=  ~CSIZE;         // Caractere de 8 bits
            tty.c_cflag |=  CS8;            // Caractere de 8 bits
            tty.c_cflag &=  ~CRTSCTS;       // Pas de contrôle de flux du matériel
            // Pas de mode canonique
            tty.c_cflag |=  ( CREAD | CLOCAL ); // Activer READ et ignorer les lignes de contrôle
            tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
            tty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
            // Récupérer les octets dès qu'ils sont disponibles
            tty.c_cc[VMIN]  = 0;           // La lecture ne block pas
            tty.c_cc[VTIME] = 10;           // 0.5 seconds de délai de lecture "timeout" ( 5 = 1/2 seconde = 0.5 )

            // Vide les Attributs du port USB
            tcflush(PortUSB, TCIFLUSH);

            // Applique les Attributs - Si pas erreur
            if ( tcsetattr ( PortUSB, TCSANOW, &tty ) != 0)
            {
                printf("Erreur %d de transmission/reception tcsetattr.\n", errno);
            }
        }
        else
        {
            printf("Erreur [%d] en provenance de tcgetattr : [%s].\n", errno, strerror(errno));
        }
    }
    else
    {
        // Affichage de lerreur
        printf("Erreur %d a louverture du port /dev/ttyACM0.\n", errno);
    }
}

int main ()
{
    // Initialisation
    setup();
    memset(&strCmd, '\0', sizeof(strCmd));
    while (strCmd[0] != '*')
    {
        printf("Entrez la commande à envoyer : ");
        lec = scanf("%s", strCmd);

        // Envoie de la commande
        reswrt = write(PortUSB, strCmd, sizeof(strCmd));
        usleep((4 + 25) * 1000);

        bascule = 1;
        while (bascule == 1)
        {
            if (!(PortUSB < 0 ))
            {
                usleep((4 + 25) * 1000);
                bascule = 0;
                // Vide la mémoire
                memset(&lecture, '\0', sizeof(lecture));
                // Lecture de la réponse
                reslec = read(PortUSB, &lecture, sizeof(lecture));
                if (sizeof(lecture) > 0)
                {
                    printf("[%s]\n", lecture);
                }
            }
            else
            {
                usleep(100);
            }
        }
    }

    close(PortUSB);

    return(0);
}


Merci de votre attention
Michel
0
yg_be Messages postés 23422 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 12 janvier 2025 1 557
3 janv. 2022 à 11:47
bonjour,
peux-tu alors marquer la discussion comme résolue?
0
Réponse 3 / 3
Michel_pc4 Messages postés 5 Date d'inscription samedi 1 janvier 2022 Statut Membre Dernière intervention 11 janvier 2022
3 janv. 2022 à 17:32
Bonjour,

Bien sur, je suis désolé de mon ignorance, il y a tellement longtemps que je n'étais venu sur le site ...

je laisse quand même une dernière version amélioré qui prend en considération la lenteur de Arduino. 

//*****************************************************************************************************
// Linux Mint 20.1 - Code::Blocks 20.03
// MiB
// Version V.104 a
//
//*****************************************************************************************************
// C - Librairie d'entête

#include <stdio.h>      // Definition des entrés et sorties standard
#include <stdlib.h>
#include <string.h>     // Definition des chaines de caracteres

#include <unistd.h>     // Definition des fonctions standard de UNIX
#include <fcntl.h>      // Contient les constantes de contrôle de fichier ex.: O_RDWR
#include <errno.h>      // Erreur integer Et strerror() function
#include <termios.h>    // Contient les définitions de contrôle pour le terminal POSIX

#include <sys/ioctl.h>
#include <linux/usbdevice_fs.h>


#define Taille 256

// Variable du port USB
int PortUSB;
struct termios tty, old_tio, new_tio;

// Variable de saisie au clavier
char strEntree[256]="1";        // Variable tampon de la lecture au clavier
char strCmd[256]="1";           // Variable local du contenu de lecture au clavier
char strAncCmd[256]="1";        // Variable local du contenu n-1 de lecture au clavier
char * lectureclavier="";       // Variable témoin d'entrée au clavier "fgets"

unsigned char lecture[Taille];  // Variable tampon d'entrée pour le port USB
int reslec;                     // Variable témoin d'entrée (read) pour le port USB
int reswrt;                     // Variable témoin de sortie (write) pour le port USB
int lec;                        // Variable local de lecture au clavier
int bascule;


void setup()
{
    // Obtenir les paramètres du terminal pour stdin
    tcgetattr(STDIN_FILENO,&old_tio);
    new_tio = old_tio;

    // Initialise l'espace mémoire nécessaire au port USB
    memset (&tty, 0, sizeof tty);
    // Ouverture du port
    PortUSB = open( "/dev/ttyACM0", O_RDWR );

    // Si pas erreur
    if (!(PortUSB < 0 ))
    {
        // Obtenir les Attributs du port USB
        if ( tcgetattr ( PortUSB, &tty ) == 0 )
        {
            // Configure les vitesses entrée/sortie
            cfsetspeed (&tty, 9600); // Configure la vitesse en entrée
            // Réglage d'autres éléments du port
            tty.c_cflag &=  ~PARENB;        // Pas de bit de parité
            tty.c_cflag &=  ~CSTOPB;        // Seulement besoin 1 stop bit
            tty.c_cflag &=  ~CSIZE;         // Caractere de 8 bits
            tty.c_cflag |=  CS8;            // Caractere de 8 bits
            tty.c_cflag &=  ~CRTSCTS;       // Pas de contrôle de flux du matériel
            // Pas de mode canonique
            tty.c_cflag |=  ( CREAD | CLOCAL ); // Activer READ et ignorer les lignes de contrôle
            tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON);
            tty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
            // Récupérer les octets dès qu'ils sont disponibles
            tty.c_cc[VMIN]  = 0;           // La lecture ne block pas
            tty.c_cc[VTIME] = 10;           // 0.5 seconds de délai de lecture "timeout" ( 5 = 1/2 seconde = 0.5 )

            // Vide les Attributs du port USB
            tcflush(PortUSB, TCIFLUSH);

            // Applique les Attributs - Si pas erreur
            if ( tcsetattr ( PortUSB, TCSANOW, &tty ) != 0)
            {
                printf("Erreur %d de transmission/reception tcsetattr.\n", errno);
            }
        }
        else
        {
            printf("Erreur [%d] en provenance de tcgetattr : [%s].\n", errno, strerror(errno));
        }
    }
    else
    {
        // Affichage de lerreur
        printf("Erreur %d a louverture du port /dev/ttyACM0.\n", errno);
    }
}

int main ()
{
    // Initialisation
    setup();
    memset(&strCmd, '\0', sizeof(strCmd));
    while (strCmd[0] != '*')
    {
        printf("Entrez la commande à envoyer : ");
        lectureclavier = fgets(strEntree,254,stdin);
        strncpy(strCmd, strEntree, strlen(strEntree)-1);

        // Envoie de la commande
        if (strcmp(strCmd,strAncCmd)!=0)
        {
            if (strCmd[0] != '*')
            {
                reswrt = write(PortUSB, strCmd, sizeof(strCmd));
                strcpy(strAncCmd,strCmd);
                usleep(20 * 100000);
                memset(&lecture, '\0', sizeof(lecture));// Vide la mémoire
                reslec = read(PortUSB, &lecture, sizeof(lecture));// Lecture de la réponse
                if (sizeof(lecture) > 0)
                {
                    printf("%s", lecture);
                }
            }
        }
    }

    close(PortUSB);

    return(0);
}


Merci de votre attention.
Michel
0