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.

@+