Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Raspberry Pi Discussion :

Gestion des GPIO !


Sujet :

Raspberry Pi

  1. #1
    Expert éminent sénior
    Gestion des GPIO !
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  2. #2
    Expert éminent sénior
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  3. #3
    Expert éminent sénior
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  4. #4
    Expert éminent sénior
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

  5. #5
    Expert éminent sénior
    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.

    @+
    Si vous êtes de mon aide, vous pouvez cliquer sur .
    Mon site : http://www.jcz.fr

###raw>template_hook.ano_emploi###