Test port série en C

**medi2006** · 07/05/2015, 15h37

Bonjour

j'ai trouvé un programme qui permet de lire le port série et écrire ce qui a été lu dans un buffer ,etant donnée que j'ai pas de periphérique pour le moment qui permettrai d'envoyer des données , je me demande si il y a moyen de tester ce programme tout de meme

je suis sous Debian

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 <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
 
 
 
int main(void)
{
 
    int port_serie;
    struct termios options;
    int reception;
    FILE* fichier = NULL;
    char buffer[16] = "";
    char data[] = ":0103070D005098\r\n"; //message que tu veux envoyer
 
 
    port_serie = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY);//lecture et ecriture | pas controlling terminal | ne pas attendre DCD
 
    //cas d'erreur d'ouverture
    if(port_serie < 0)
    {
        perror("Erreur d'ouverture du port serie");
        exit(-1);
    }
 
    else
    {
        printf("Port serie numero %d bien ouvert. \n", port_serie);
 
        //chargement des données
        tcgetattr(port_serie, &options);
        //B115200 bauds
        cfsetospeed(&options, B115200);
        options.c_cflag |= (CLOCAL | CREAD);//programme propriétaire du port
        //structure en 8N1 !!
        options.c_cflag &= ~PARENB; //pas de parité
        options.c_cflag &= ~CSTOPB; // 1 bit de stop
        options.c_cflag &= ~CSIZE; //option a 0
        options.c_cflag |= CS8; //8 bits
        tcsetattr(port_serie, TCSANOW, &options); //enregistrement des valeurs de configuration
        printf("Configuration OK strcuture en 8N1 !. \n");
 
            // Envoie de donnees.
            //printf("Envoie des donnees en cours ... \n");
            //if (write(port_serie, data, 17) < 0){perror("ERROR\n");}
            //printf("Envoie Termine. \n");
 
 
            //printf("Attente. \n");
            //sleep(2);
            //printf("Fin Attente. \n");
 
 
            // Lecture des donnees.
            printf("Lecture des donnees en cours ... \n");
            fcntl(port_serie,F_SETFL,10);//mode bloquant pour la fonction read() si aucun caractere dispo, programme attend
 
            reception=read(port_serie,buffer,16);//buffer contitendra les données, 16 est le nombre d'octets a copier dans cet espace
            printf("message recu : %s\n",buffer);
 
 
 
 
            if (reception == -1)
            printf("Erreur lecture port serie\n");
 
            printf("Reception finie.\n" );
 
    }
 
    close(port_serie);//fermeture du port serie
 
 
return 0;
}

j'ai en sortie Erreur d'ouverture du port serie: Permission denied

**sambia39** · 07/05/2015, 20h57

Bonsoir

Envoyé par medi2006

j'ai en sortie Erreur d'ouverture du port serie: Permission denied

Pour utiliser le port série, il faut avoir les droits adéquats d'exécution c'est-à-dire exécuter en tant qu'administrateurs.

remarque en rouge : c'est bien de configurer mais où est passé l'ancienne configuration ? penser toujours à une restitution du contexte pour ceux type de programme.

Envoyé par medi2006

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
 ........
    port_serie = open("/dev/ttyS0", O_RDWR | O_NOCTTY | O_NDELAY);//lecture et ecriture | pas controlling terminal | ne pas attendre DCD
 
  .........
        //chargement des données
        tcgetattr(port_serie, &options);
        //B115200 bauds
        cfsetospeed(&options, B115200);
        options.c_cflag |= (CLOCAL | CREAD);//programme propriétaire du port
        //structure en 8N1 !!
        options.c_cflag &= ~PARENB; //pas de parité
        options.c_cflag &= ~CSTOPB; // 1 bit de stop
        options.c_cflag &= ~CSIZE; //option a 0
        options.c_cflag |= CS8; //8 bits
        tcsetattr(port_serie, TCSANOW, &options); //enregistrement des valeurs de configuration
        printf("Configuration OK strcuture en 8N1 !. \n");
  
            // Envoie de donnees.
            //printf("Envoie des donnees en cours ... \n");
            //if (write(port_serie, data, 17) < 0){perror("ERROR\n");}
            //printf("Envoie Termine. \n");
  
  
            //printf("Attente. \n");
            //sleep(2);
            //printf("Fin Attente. \n");
  
  
            // Lecture des donnees.
            printf("Lecture des donnees en cours ... \n");
            fcntl(port_serie,F_SETFL,10);//mode bloquant pour la fonction read() si aucun caractere dispo, programme attend
  
            reception=read(port_serie,buffer,16);//buffer contitendra les données, 16 est le nombre d'octets a copier dans cet espace
            printf("message recu : %s\n",buffer);
  
  
  
  
            if (reception == -1)
            printf("Erreur lecture port serie\n");
  
            printf("Reception finie.\n" );
  
    }
  
    close(port_serie);//fermeture du port serie
 
  
return 0;
}

Autre point, il faut sauvegarder l'ancienne configuration pour la restituer plus tard après la fin du traitement de vos données.
Il faut également vérifier si l'on lit bien les données ou en a bien écrie les données en cas d'erreur faire le nécessaire (restitué l'ancienne configuration et fermer voir libérée de la mémoire allouer ).
voici un petit exemple tiré du tien mais qui est susceptible de porter des erreurs ( écris trop vite ) à bientôt

Code C :

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
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
 
#define	BUFFER		15
#define BAUDRATE	B19200
 
/**
 * Donnée à traiter
 */
typedef struct s_Config{
	int fd;
	char *ptr_data;
	struct termios oldTerm;
	struct termios newTerm;
}ts_Config;
 
/**
 * Fonction d'initialisation
 */
ts_Config *f_Init_Create_new_Config( void ){
 
	ts_Config *ptr = NULL;
	ptr = (ts_Config*)calloc( 1, sizeof( ts_Config) );
	if( (NULL) == ptr ){
		fprintf( stderr, "Erreur allocation new config %s\n",
				strerror(errno) );
		return ( NULL );
	}
	ptr->fd = 0;
	ptr->ptr_data = NULL;
	ptr->ptr_data = (char*)calloc( BUFFER, sizeof(char) );
	if( (NULL) == ptr->ptr_data ){
		free( ptr );
		ptr = NULL;
		fprintf(stderr, "Erreur allocation data liaison\n %s\n",
				strerror(errno) );
		return( NULL );
	}
	return( ptr );
}
 
/**
 * Configuration
 */
void f_ConfigSaveTerm( ts_Config *ptr_data ){
 
	/*	Sauvegarde des configuration	*/
	tcgetattr( ptr_data->fd, &(ptr_data->oldTerm) ); /*	Ancienne	*/
	tcgetattr( ptr_data->fd, &(ptr_data->newTerm) ); /* Nouvelle	*/
 
	/*	Ex de config & option nouvelle */
	ptr_data->newTerm.c_oflag = 0L;
	ptr_data->newTerm.c_lflag = 0L;
	ptr_data->newTerm.c_cc[VMIN] = 1;
	ptr_data->newTerm.c_cc[VTIME] = 0;
	ptr_data->newTerm.c_cflag |= CS8;
	ptr_data->newTerm.c_cflag |= CREAD;
	ptr_data->newTerm.c_cflag |= CLOCAL;
	ptr_data->newTerm.c_lflag = IGNBRK;
	ptr_data->newTerm.c_cflag &= ~(CSIZE|PARENB|CSTOPB);
	ptr_data->newTerm.c_iflag &= ~(IXON|IXOFF|IXANY);
 
	cfsetispeed( &(ptr_data->newTerm), BAUDRATE );
	cfsetospeed( &(ptr_data->newTerm), BAUDRATE );
 
	/* Application de la nouvelle configuration */
	tcsetattr( ptr_data->fd, TCSANOW, &(ptr_data->newTerm) );
	tcflush( ptr_data->fd, TCIFLUSH );
}
 
/**
 * Destruction de l'ensemble des donnée
 */
void f_FreeConfig( ts_Config *ptr ){
 
	ptr->fd = 0;
	free( ptr->ptr_data );
	ptr->ptr_data = NULL;
	free( ptr );
	ptr = NULL;
}
 
/**
 * fonction Close Liaison &
 */
void f_ResetLiaison( ts_Config *ptr ){
	tcsetattr( ptr->fd, TCSANOW, &(ptr->oldTerm) );
	f_FreeConfig( ptr );
}
 
/**
 * Fonction Principale
 */
int main( void ){
 
	int i_read = 0;
	char c_str = '\0';
	ts_Config *ptr = NULL;
	unsigned int i_Cmpt = 0;
 
	/* Initialisation et configuration */
	ptr = f_Init_Create_new_Config();
	if( (NULL) == ptr )
		exit( EXIT_FAILURE );
	f_ConfigSaveTerm( ptr );
 
	/*	Ouverture de la liaison */
	ptr->fd = open( "/dev/tty0", O_RDWR|O_NOCTTY );
	if( (-1) == ptr->fd ){
		f_ResetLiaison( ptr );
		fprintf( stderr, "Erreur ouverture de la liaison %s\n",
				strerror(errno) );
		return( EXIT_FAILURE );
	}
 
	/*	Ex lecture data	*/
	do{
		i_read = read( ptr->fd, &c_str, 1 );
		if( (-1) == i_read ){
			close( ptr->fd );
			f_ResetLiaison( ptr );
			fprintf(stderr, "Erreur de lecture data %s\n",
					strerror(errno) );
			exit( EXIT_FAILURE );
		}
		*( ptr->ptr_data + i_Cmpt) = c_str;
		i_Cmpt += 1;
	}while( BUFFER > i_Cmpt );
 
	/*	Affichage	*/
	printf(">>\t%s\n", ptr->ptr_data );
	memset( ptr->ptr_data, 0, BUFFER );
 
	/*	fermeture	*/
	close( ptr->fd );
	f_ResetLiaison( ptr );
 
	return( EXIT_SUCCESS );
}

**medi2006** · 08/05/2015, 14h11

Merci beaucoup de votre réponse
mais une autre question, comment je pourrai le lancer comme administrateur, je suis sous debian et je sais pas trop comment l'utiliser pour le moment
et comment je pourrai aussi envoyer des données via le port série si j'ai pas de peripherique relié au port (je me demande si ça existe des ports series virtuels ou une maniere pour tester ce programme)

Cordialement

**sambia39** · 09/05/2015, 14h57

Bonjour
Pour exécuter une commande sous les droits administrateurs il faut utiliser la commande "sudo" (substitute user do) afin d'exécuter une commande sous droit administrateur et cette commande, vous donne droit à la session root (administrateur) de façon permanente ou temporaire ce changement de droit est visible avec des caractères spéciaux exemples $ pour l'utilisateur et quand il passe en session root c'est un # et pour quitter la session active en cours c'est-à-dire administrateur (root) ou utilisateur il faut taper exit

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
johlatringlet@mon_pc_unix_or_linux:~$ sudo -s
[sudo] password for johlatringlet:perefourasse
root@mon_pc_unix_or_linux:~# 
root@mon_pc_unix_or_linux:~# exit
johlatringlet@mon_pc_unix_or_linux:~$

pour exécuter ton programme sous les droits administrateurs ça sera donc soit directement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
johlatringlet@mon_pc_unix_or_linux:~$ sudo ./rs232_debug
[sudo] password for johlatringlet:perefourasse
Port RS232 OK

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
johlatringlet@mon_pc_unix_or_linux:~$ sudo -s
[sudo] password for johlatringlet:perefourasse
root@mon_pc_unix_or_linux:~#./rs232_debug
Port RS232 OK

à bientôt

**InitSreen** · 09/05/2015, 17h26

Envoyé par medi2006

comment je pourrai aussi envoyer des données via le port série si j'ai pas de peripherique relié au port (je me demande si ça existe des ports series virtuels ou une maniere pour tester ce programme)
Cordialement

Si tu as un câble série croisé et deux ports séries sur ton système, tu peux faire une "loopback" entre les deux ports séries. Pour le nombre de fils du câble, ça dépend de ta config pour le contrôle de flux (RTS/CTS: 5 fils, XON/XOFF: 3 fils).

Test port série en C

C

Discussions similaires

Partager

Partager