Discussion :

[RPGamer]

Salut,

Je réalise le programme pour un petit robot équipé d'une carte RoBoard. La carte RoBoard peut être programmée avec la librairie RoBoIO rendant théoriquement les accès aux GPIO, port I2C, COM, SPI, etc. très faciles. C'est la première fois que je fais ça.

J'ai pris la version déjà compilée pour Linux depuis le site officiel du fabricant : http://www.roboard.com/download_ml.htm

Je développe avec Code::Blocks. J'ai donc ajouté les chemins Include/ et Lib/ dans Settings->Compiler...->Search directories et j'ai ajouté le fichier .a dans les options du projet via Project->Build options...->Linker settings.

Si je crée un programme en commençant avec un #include <roboard.h> comme indiqué dans les exemples, tout semble compiler correctement. Mon problème survient si plusieurs programmes incluent eux-mêmes roboard.h et que je les inclus dans un autre programme. Par exemple :

io.h

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
#ifndef __IO_H
#define __IO_H
 
#include <stdbool.h>
 
/* Nombre maximum de pins sur la RoBoard */
#define MAX_PINS    32
 
void io_register_pin(int pin);
void io_unregister_pin(int pin);
bool io_pin_is_registered(int pin);
void io_set_rb_version(void);
void io_init_lib(void);
void io_destroy(void);
 
#endif // __IO_H

io.c

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
#include "io.h"
#include "servo.h"
#include <stdio.h>
#include <roboard.h>
 
/* Tableau pour l'enregistrement des pins utilisees */
static bool pins[MAX_PINS];
 
void io_init_lib(void) {
 
    int i;
    long use_pin = 0;
    Servo *servos[MAX_PINS];
    int nb_servos = 0;
 
    // initialisation de la version de la RoBoard
    roboio_SetRBVer(RB_110);
 
    // recuperation des servos enregistres
    servo_get_elements(servos, &nb_servos);
 
    // si au moins 1 servo a ete enregistre
    if (nb_servos > 0) {
 
        for (i = 0; i < nb_servos; i++) {
 
            // on ajoute les pin utilisees pour les servos
            use_pin += servos[i]->use_pin;
 
        }
 
    }
 
    else {
 
        // pour les GPIO des capteurs on n'associe aucune pin
        use_pin = RCSERVO_USENOPIN;
 
    }
 
    // initialisation de la lib
    if (!rcservo_Init(use_pin)) {
 
        fprintf(stderr, "Impossible d'initialiser la RC Servo lib (%s).", roboio_GetErrMsg());
 
    }
 
}
 
void io_register_pin(int pin) {
 
    pins[pin] = true;
 
}
 
void io_unregister_pin(int pin) {
 
    pins[pin] = false;
 
}
 
bool io_pin_is_registered(int pin) {
 
    return pins[pin];
 
}
 
void io_destroy(void) {
 
    rcservo_Close();
 
}

gpio.h

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
#ifndef __GPIO_H
#define __GPIO_H
 
/* Etats possibles pour un GPIO. */
typedef enum {
    LOW,
    HIGH
} GPIO_STATE;
 
/* Structure d'un GPIO. */
typedef struct {
    char *name;
    int pin;
    GPIO_STATE state;
} GPIO;
 
void gpio(GPIO *gpio, char *name, int pin);
void gpio_enable(GPIO *gpio);
void gpio_disable(GPIO *gpio);
void gpio_switch(GPIO *gpio);
void gpio_get_elements(GPIO **gpio_elements, int *number);
void gpio_destroy(GPIO *gpio);
 
#endif // __GPIO_H

gpio.c

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
#include "gpio.h"
#include "io.h"
#include <stdio.h>
#include <string.h>
#include <roboard.h>
 
/* Tableau pour l'enregistrement des GPIO */
static GPIO *gpios[MAX_PINS];
static int nb_gpios = 0;
 
void gpio(GPIO *gpio, char *name, int pin) {
 
    // on verifie si la pin nest pas deja utilisee
    if (io_pin_is_registered(pin)) {
 
        fprintf(stderr, "La pin RCSERVO_PINS%d est deja utilisee.\n", pin);
        return;
 
    }
 
    // initialisatiion et enregistrement de la structure du GPIO
    strcpy(gpio->name, name);
    gpio->pin = pin;
    gpio->state = LOW;
    gpios[nb_gpios++] = gpio;
 
    // enregistrement de la pin
    io_register_pin(pin);
 
}
 
void gpio_enable(GPIO *gpio) {
 
    rcservo_OutPin(gpio->pin, HIGH);
    gpio->state = HIGH;
 
}
 
void gpio_disable(GPIO *gpio) {
 
    rcservo_OutPin(gpio->pin, LOW);
    gpio->state = LOW;
 
}
 
void gpio_switch(GPIO *gpio) {
 
    rcservo_OutPin(gpio->pin, gpio->state == LOW ? HIGH : LOW);
 
}
 
void gpio_get_elements(GPIO **gpio_elements, int *number) {
 
    gpio_elements = gpios;
    *number = nb_gpios;
 
}
 
void gpio_destroy(GPIO *gpio) {
 
    int i;
    for (i = 0; i < nb_gpios; i++) {
 
        if (gpios[i]->pin == gpio->pin) {
 
            gpios[i] = NULL;
            io_unregister_pin(gpio->pin);
            break;
 
        }
 
    }
 
}

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>
#include <stdlib.h>
 
#include "io/gpio.h"
 
int main()
{
 
       // utilisation des GPIO
 
       return EXIT_SUCCESS;
}

Si je tente de compiler, j'ai une série d'erreurs de type multiple definition of '' sur chaque fonction de la librairie.

Pourtant le code du fichier roboard.h dans le répertoire Include/ est le suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#ifndef __ROBOARD_H
#define __ROBOARD_H
 
#include "common.h"
#include "io.h"
#include "rcservo.h"
#include "spi.h"
#include "ad79x8.h"
#include "i2c.h"
#include "com.h"
 
#endif

Il me semble que les directives préprocesseur devraient empêcher toute inclusion multiple en cas d'utilisation de plusieurs programmes faisant appels à des fonctions de cette librairie.

Merci d'avance pour toute aide ou explication