Gestion des GPIO

**Artemus24** · 14/07/2020, 13h12

Salut à tous.

Le but de ce sujet n'est pas de reprendre les exemples que l'on peut trouver sur le net pour manipuler les GPIO dans des langages comme 'C/C++' ou python.
Je parle bien sûr de l'appel à des bibliothèques comme "wiringPi" ou comme "bcm2835".
La plupart de ces exemples sont basiques et fort mal commentés, donc sans intérêt.

Je cherche des explications sur comment piloter les GPIO en 'C/C++'.

En premier lieu, il y a quelques changement dans la façon de gérer les GPIO de la Raspberry Pi.
Les manipulations se faisant jusqu'à présent soit avec "SysFS" ou soit avec "devmem".
Depuis linux 4.8, l'interface GPIO "SysFS" est déconseillée.

Voici un exemple de manipulation de la GPIO18 afin de faire clignoter une led, avec "SysFS" :

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
/****************************************/
/*                                      */
/*     Pilotage des GPIO Avec SysFS     */
/*                                      */
/****************************************/
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
/*************************************/
/*                                   */
/*     Déclaration des Fonctions     */
/*                                   */
/*************************************/
 
int	fd;
 
void GPIO_Out(int pin)
{
	char	buffer[255];
 
	sprintf(buffer, "/sys/class/gpio/export");
 
	if ((fd = open(buffer, O_WRONLY)) == -1)
	{
		perror("GPIO_Out 1 : ");
		exit(1);
	}
 
	sprintf(buffer, "%d", pin);
 
	if (write(fd, buffer, strlen(buffer)) != (ssize_t)strlen(buffer))
	{
		perror("GPIO_Out 2 : ");
		exit(1);
	}
 
	close(fd);
 
	sprintf(buffer, "/sys/class/gpio/gpio%d/direction", pin);
 
	if ((fd = open(buffer, O_WRONLY)) == -1)
	{
		perror("GPIO_Out 3 : ");
		exit(1);
	}
 
	if (write(fd, "out", 3) != 3)
	{
		perror("GPIO_Out 4 : ");
		exit(1);
	}
 
	close(fd);
 
	sprintf(buffer, "/sys/class/gpio/gpio%d/value", pin);
 
	if ((fd = open(buffer, O_WRONLY)) == -1)
	{
		perror("GPIO_Out 5 : ");
		exit(1);
	}
}
 
int GPIO_On(int _sleep)
{
	usleep(_sleep);
	return write(fd, "1", 1);
}
 
int GPIO_Off(int _sleep)
{
	usleep(_sleep);
	return write(fd, "0", 1);
}
 
void GPIO_Finish(int pin)
{
	char	buffer[255];
 
	close(fd);
 
	sprintf(buffer, "/sys/class/gpio/unexport");
 
	if ((fd = open(buffer, O_WRONLY)) == -1)
	{
		perror("GPIO_Finish 1 : ");
		exit(1);
	}
 
	sprintf(buffer, "%d", pin);
 
	if (write(fd, buffer, strlen(buffer)) != (ssize_t)strlen(buffer))
	{
		perror("GPIO_Finish 2 : ");
		exit(1);
	}
 
	close(fd);
}
 
/********************************/
/*                              */
/*     Procédure Principale     */
/*                              */
/********************************/
 
int main(void)
{
	GPIO_Out(18);
 
	for (int i = 0; i < 100; i++)
	{
		GPIO_On(50000);
		GPIO_Off(50000);
	}
 
	GPIO_Finish(18);
 
	exit(EXIT_SUCCESS);
}

Je n'ai traité dans cet exemple qu'une seule led.
Si l'on doit gérer plusieurs leds, il faut stocker dans un tableau, les FD de chaque led.

Je découvre qu'il existe un nouvel API qui se nomme "libgpiod".

Pour ceux que cela intéresse, il y a la conférence FOSDEM de Février/2018 (New GPIO interface for linux user space).

Et voici un commentaire fort intéressant sur la présentation de cette noiuvelle interface "linux/gpio.h".
--> https://www.blaess.fr/christophe/201...piod-partie-1/
--> https://www.blaess.fr/christophe/201...piod-partie-2/

Mon but est de développer une petite bibliothèque de manipulation des GPIO de la raspberry, quelque chose de basique.

@+

**Artemus24** · 14/07/2020, 17h50

Salut à tous.

Je sais maintenant comment piloter les GPIO, sans passer par les bibliothèques.
Voici comment faire clignoter deux leds en alternances :

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
/*******************************************************/
/*                                                     */
/*     Faire Clignoter une led avec "linux/gpio.h"     */
/*                                                     */
/*******************************************************/
 
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include <linux/gpio.h>
#include <sys/ioctl.h>
 
/********************************/
/*                              */
/*     Procédure Principale     */
/*                              */
/********************************/
 
int main(void)
{
	struct gpiohandle_request	_req;
	struct gpiohandle_data		_val;
 
	memset(&_req, 0, sizeof(struct gpiohandle_request));
 
	if ((_req.fd = open("/dev/gpiochip0", O_RDONLY)) < 0)
	{
		printf("Erreur à l'ouverture de la GPIO 18\n");
		exit(EXIT_FAILURE);
	}
 
	_req.lineoffsets[0]	= 18;
	_req.lineoffsets[1]	= 13;
	_req.flags		= GPIOHANDLE_REQUEST_OUTPUT;
	_req.lines		= 2;
 
	if (ioctl(_req.fd, GPIO_GET_LINEHANDLE_IOCTL, &_req) < 0)
	{
		close(_req.fd);
		exit(EXIT_FAILURE);
	}
 
	_val.values[0] = 0;	/* GPIO18 : off */
	_val.values[1] = 1;	/* GPIO13 : on  */
 
	for (int i=0; i<100; i++)
	{
		_val.values[0] = 1 - _val.values[0];
		_val.values[1] = 1 - _val.values[1];
 
		if (ioctl(_req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &_val) < 0)
			break;
 
		usleep(50000);
	}
 
	close(_req.fd);
 
	exit(EXIT_SUCCESS);
}

Deux leds, une rouge et une jaune.
Deux résistances de 300 ohms.
--> GPIO18 : broche 12
--> GPIO13 : broche 33

Le programme n'est pas si compliqué à faire. Pour l'instant, je n'ai traité que les sorties (output) de leds.
Prochain épisode, les entrées (input) d'interrupteurs.

@+

**Artemus24** · 16/07/2020, 23h25

Salut à tous.

Cette fois-ci, j'utilise un bouton poussoir (GPIO17) et une led (GPIO22).
La led est reste allumée, tant que l'on n'appuie pas sur le bouton.

Voici l'exemple, qui reste basique et montre comment déclarer un GPIO en input.
En fait, c'est très similaire à un GPIO en OUTPUT.
Juste une remarque, je suis obligé de faire deux déclaratives et non de tout mettre dans la même déclarative.

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
/******************************************************************/
/*                                                                */
/*     Cesser de faire Clignoter une led avec un interrupteur     */
/*                                                                */
/******************************************************************/
 
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include <linux/gpio.h>
#include <sys/ioctl.h>
 
/********************************/
/*                              */
/*     Procédure Principale     */
/*                              */
/********************************/
 
int main(void)
{
	struct gpiohandle_request	 in_req;
	struct gpiohandle_request	out_req;
 
	struct gpiohandle_data		 in_val;
	struct gpiohandle_data		out_val;
 
	memset( &in_req, 0, sizeof(struct gpiohandle_request));
	memset(&out_req, 0, sizeof(struct gpiohandle_request));
 
 
	if ((in_req.fd  = open("/dev/gpiochip0", O_RDONLY)) < 0)
	{
		close(in_req.fd);
		exit(EXIT_FAILURE);
	}
 
	if ((out_req.fd = open("/dev/gpiochip0", O_RDONLY)) < 0)
	{
		close(out_req.fd);
		exit(EXIT_FAILURE);
	}
 
	 in_req.lineoffsets[0]	= 17;
	 in_req.flags		= GPIOHANDLE_REQUEST_INPUT;
	 in_req.lines		= 1;
 
	out_req.lineoffsets[0]	= 22;
	out_req.flags		= GPIOHANDLE_REQUEST_OUTPUT;
	out_req.lines		= 1;
 
 
	if (ioctl( in_req.fd, GPIO_GET_LINEHANDLE_IOCTL, &in_req) < 0)
	{
		close( in_req.fd);
		close(out_req.fd);
		exit(EXIT_FAILURE);
	}
 
	if (ioctl(out_req.fd, GPIO_GET_LINEHANDLE_IOCTL, &out_req) < 0)
	{
		close( in_req.fd);
		close(out_req.fd);
		exit(EXIT_FAILURE);
	}
 
	for (int i=0; i<1000; i++)
	{
		if (ioctl( in_req.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL,  &in_val) < 0)
			break;
 
		out_val.values[0] = (in_val.values[0] == 0) ? 1 : 0;
 
		if (ioctl(out_req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &out_val) < 0)
			break;
 
		usleep(50000);
	}
 
	close( in_req.fd);
	close(out_req.fd);
 
	exit(EXIT_SUCCESS);
}

Dans ses deux déclaratives, on peut mettre autant de boutons et de leds que l'on veut.

@+

**Artemus24** · 17/07/2020, 04h01

Salut à tous.

J'ai externalisé les fonctions permettant de gérer les GPIO dans une bibliothèques de nom "libgpio".
Je sais, ce n'est pas très original comme nom, mais je n'avais pas d'autre idée.

Voici le fichier libgpio.c :

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
138
139
140
141
142
143
/*************************************************/
/*                                               */
/*     Bibliothèque de manipulation des GPIO     */
/*                                               */
/*************************************************/
 
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include <linux/gpio.h>
#include <sys/ioctl.h>
 
#include <libgpio.h>
 
/*************************************/
/*                                   */
/*     Déclaration des Variables     */
/*                                   */
/*************************************/
 
struct gpiohandle_request	 _in_req;
struct gpiohandle_request	_out_req;
 
struct gpiohandle_data		 _in_val;
struct gpiohandle_data		_out_val;
 
unsigned int			 _in_index;
unsigned int			_out_index;
 
unsigned char			 _in_tab[40];
unsigned char			_out_tab[40];
 
 
/*************************************/
/*                                   */
/*     Déclaration des Fonctions     */
/*                                   */
/*************************************/
 
void GPIO_Init(void)
{
	/*------------------------------------*/
	/*     Initialisation des Entrées     */
	/*------------------------------------*/
 
	memset( &_in_req, 0, sizeof(struct gpiohandle_request));
 
	if ((_in_req.fd  = open("/dev/gpiochip0", O_RDONLY)) < 0)
	{
		close(_in_req.fd);
		exit(EXIT_FAILURE);
	}
 
	memset( &_in_tab, '\0', sizeof( _in_tab));
	 _in_index = 0;
 
	/*------------------------------------*/
	/*     Initialisation des Sorties     */
	/*------------------------------------*/
 
	memset(&_out_req, 0, sizeof(struct gpiohandle_request));
 
	if ((_out_req.fd = open("/dev/gpiochip0", O_RDONLY)) < 0)
	{
		close(_out_req.fd);
		exit(EXIT_FAILURE);
	}
 
	memset(&_out_tab, '\0', sizeof(_out_tab));
	_out_index = 0;
}
 
 
void GPIO_Finish(void)
{
	close( _in_req.fd);
	close(_out_req.fd);
}
 
 
void GPIO_In(unsigned int _pin)
{
	_in_req.lineoffsets[_in_index]		= _pin;
	_in_req.flags				= GPIOHANDLE_REQUEST_INPUT;
	_in_req.lines				= _in_index + 1;
 
	_in_tab[_pin] = _in_index;
	_in_index++;
}
 
 
void GPIO_Out(unsigned int _pin)
{
	_out_req.lineoffsets[_out_index]	= _pin;
	_out_req.flags				= GPIOHANDLE_REQUEST_OUTPUT;
	_out_req.lines				= _out_index + 1;
 
	_out_tab[_pin] = _out_index;
	_out_index++;
}
 
 
void GPIO_Start(void)
{
	if (ioctl( _in_req.fd, GPIO_GET_LINEHANDLE_IOCTL, &_in_req) < 0)
	{
		close( _in_req.fd);
		close(_out_req.fd);
		exit(EXIT_FAILURE);
	}
 
 
	if (ioctl(_out_req.fd, GPIO_GET_LINEHANDLE_IOCTL, &_out_req) < 0)
	{
		close( _in_req.fd);
		close(_out_req.fd);
		exit(EXIT_FAILURE);
	}
}
 
 
int GPIO_Get(unsigned int _pin)
{
	ioctl( _in_req.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL,  &_in_val);
 
	return _in_val.values[_in_tab[_pin]];
}
 
 
void GPIO_Put(unsigned int _pin, int _val)
{
	_out_val.values[_out_tab[_pin]] = _val;
 
	ioctl(_out_req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &_out_val);
}
 
void GPIO_Delay(unsigned int _elapse)
{
	usleep(_elapse);
}

Le fichier "libgpio.h" :

Code c :

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

1
2
3
4
5
6
7
8
9
void GPIO_Init(void);
void GPIO_Finish(void);
void GPIO_In(unsigned int _pin);
void GPIO_Out(unsigned int _pin);
void GPIO_Start(void);
int  GPIO_Get(unsigned int _pin);
void GPIO_Put(unsigned int _pin, int _val);
void GPIO_Delay(unsigned int _elapse);
~

Le fichier makefile pour compiler cette bibliothèque :

Code makefile :

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
# ------------------------------- #
#   Déclaration des Executables   #
# ------------------------------- #
 
RM	= @rm -f
CC	= @gcc
EX	= @chmod +x
AR	= @ar rc
RL	= @ranlib
 
# -------------------------- #
#   Déclaration des Objets   #
# -------------------------- #
 
SRC	= main.c
OBJ	= libgpio.o
BIN	= libgpio.a
 
# ---------------------------- #
#   Déclaration des Includes   #
# ---------------------------- #
 
INC1	= -I"."
 
INCS	= $(INC1)
 
# ------------------------------ #
#   Déclaration des Paramètres   #
# ------------------------------ #
 
FLAG1	= -O -Wall -Wextra -Wpedantic
 
FLAG	= $(FLAG1)
 
# ------------------------------------ #
#   Compilation et Edition des liens   #
# ------------------------------------ #
 
all: before $(BIN) after
 
before:
	clear
	$(RM) $(OBJ)
	$(RM) $(BIN)
 
$(BIN): $(OBJ)
	$(AR) $(BIN) $(OBJ)
	$(RL) $(BIN)
 
$(OBJ): $(SRC)
	$(CC) -c $(SRC) -o $(OBJ) $(INCS) $(FLAG)
 
after:
	$(RM) $(OBJ)

C'est tout pour la bibliothèque "libgpio".

Voici le programme 'c' qui manipule deux boutons et deux leds :

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
/***************************************************/
/*                                                 */
/*     Allumer des leds avec des interrupteurs     */
/*                                                 */
/***************************************************/
 
#include <stdlib.h>
#include <libgpio.h>
 
/********************************/
/*                              */
/*     Procédure Principale     */
/*                              */
/********************************/
 
int main(void)
{
	GPIO_Init();
 
	GPIO_In(14);
	GPIO_In(17);
 
	GPIO_Out(22);
	GPIO_Out(25);
 
	GPIO_Start();
 
	for (int i=0; i<1000; i++)
	{
		GPIO_Put(22, GPIO_Get(14));
		GPIO_Put(25, GPIO_Get(17));
 
		GPIO_Delay(50000);
	}
 
	GPIO_Finish();
	exit(EXIT_SUCCESS);
}

Et le fichier makefile :

Code makefile :

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
# ------------------------------- #
#   Déclaration des Executables   #
# ------------------------------- #
 
RM	= @rm -f
CC	= @gcc
EX	= @chmod +x
 
# -------------------------- #
#   Déclaration des Objets   #
# -------------------------- #
 
SRC	= main.c
OBJ	= main.o
BIN	= gpio
 
# ---------------------------- #
#   Déclaration des Includes   #
# ---------------------------- #
 
INC1	= -I"."
INC2	= -I"include/"
 
INCS	= $(INC1) $(INC2)
 
# --------------------------------- #
#   Déclaration des Bibliothèques   #
# --------------------------------- #
 
LIBS	= -L"include/"
 
ADD	= "include/libgpio.a"
 
# ------------------------------ #
#   Déclaration des Paramètres   #
# ------------------------------ #
 
FLAG1	= -O -Wall -Wextra -Wpedantic
 
FLAG	= $(FLAG1)
 
# ------------------------------------ #
#   Compilation et Edition des liens   #
# ------------------------------------ #
 
all: before $(BIN) after
 
before:
	clear
	$(RM) $(OBJ)
	$(RM) $(BIN)
 
$(BIN): $(OBJ)
	$(CC)    $(OBJ) $(INCS) $(ADD) -o $(BIN) $(LIBS)
 
$(OBJ): $(SRC)
	$(CC) -c $(SRC) $(INCS)        -o $(OBJ) $(FLAG)
 
after:
	$(RM) $(OBJ)
	$(EX) $(BIN)
	@./$(BIN)

Le programme est fort simple.
Il y a deux boutons. Quand vous appuyez sur l'un des boutons vous allumez une led et quand c'est l'autre boutons, c'est l'autre led qui s'allume.

Ce programme est un exemple de manipulation des boutons et des leds que l'on peut améliorer.

@+

**Artemus24** · 22/07/2020, 01h39

Salut à tous.

Je cherche à perfectionner cette bibliothèque "libgpio.h" que j'aurai dû nommer "mylibgpio.h".
Je sais gérer les GPIO en lecture et en écriture.
Il me reste à faire la gestion des pull-up et des pull-down.
Pour l'instant, je n'ai rien trouvé de probant.
Si quelqu'un a un piste de recherche, je suis preneur.

Sinon, qu'est-ce que j'ai d'autre à faire ?
A part activer ou désactiver le pull-up et le pull-down, je ne vois rien d'autre.

@+

Gestion des GPIO

Raspberry Pi

Vue hybride

Discussions similaires

Partager

Partager