Discussion :

[JuanLuis]

Bonjour,

Je suis en train de concevoir une nouvelle couche logiciel sur un projet existant, pour permettre de séparer le code applicatif des drivers de communication (SPI,RS232,I2C...). Le but est d'avoir dans l'applicatif que des appel de fonctions simple, facile à lire, du genre Lire(périphérique_N,Adresse).
Ma nouvelle couche logicielle doit faire le lien entre l'applicatif et le bon driver a utiliser pour le périphérique demandé. Le tout en passant les bon arguments au driver, sachant que les drivers pour les différentes communications reçoivent des paramètres différents.

J'aimerai donc avoir des pistes, des idées sur ce sur quoi je dois bien réfléchir pour réaliser ça.
Le but final de cette couche est d'être réutilisée dans différents projets,tel une librairie, elle doit donc pouvoir se modifier facilement si on ajoute ou enlève un type de communication (SPI,i2C,etc...).

Je cherche donc les problématiques sur lesquels me pencher afin de bien réaliser ça. Je travail obligatoirement en C sur PIC18f.
Merci d'avance. JL

[SesechXP]

Bonjour,

Idée à creuser mais je crois que je créerais pour chaque type de liaison une structure indiquant les paramètres. Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
typedef struct i2c__config
{
    uint8_t address;
} i2c__config_t;

typedef struct spi_config
{
    uint8_t mode;
    bool    cs_invert;
} spi__config_t;

Ensuite on passe ces paramètres à l'aide d'un pointeur générique.

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
int main(void)
{
    i2c__config_t i2c_parameters =
    {
        .address = 0xAA
    };
    device1__initialize(&i2c_parameters);

    spi__config_t spi_parameters =
    {
        .mode = 0,
        .cs_invert = true
    };
    device2__initialize(&spi_parameters);

void device1__initialize(void* p_parameters)
{
    i2c__config_t* p_i2c_parameters = (i2c__config_t*)p_parameters;

    printf
    (
        "I2C parameters: \n.address = %d\n",
        p_i2c_parameters->address
    );
}

void device2__initialize(void* p_parameters)
{
    spi__config_t* p_spi_parameters = (spi__config_t*)p_parameters;

    printf
    (
        "SPI parameters: \n.mode = %d\n.cs_invert = %d\n",
        p_spi_parameters->mode,
        p_spi_parameters->cs_invert
    );
}

De cette manière, les périphériques device1 et device2 ont la même API mais utilisent des paramètres différents.

PS : ne pas oublier de vérifier les pointeurs...

[JuanLuis]

Merci pour la réponse SesechXP !

C'est une piste que je pensais utiliser; les structures.
Comme je veux un applicatif le plus générique possible, je pensais passer par une fonction pour définir les structures et pour assigner les champs.
En gros :

main.c

Code :

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

1
2
3
4
5
6
int	main() //Mon applicatif
{
  lire(nom_du_périphérique,adresse de sauvegarde)
//ou
  ecrire(nom_du_périphérique,adresse de la donnée)
}

couche_intermédiaire.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
lire(nom_du_périph, adresse)
{
   if(nom_du_périph==GPS)
   {   
        SPI    spi_paramètre       //définission de la structure SPI
       //la on renseigne tous les champs de la structure "SPI_paramètre"
        SPI_paramètre.vitesse = XXXXX
        SPI_paramètre.longueur = XXXXX
        SPI_paramètre.donnée = XXXXX
        
        protocole_lecture(&SPI_paramètre) //là on appel le driver en passant la structure en argument
   }
   elsif(nom_du_périph==GPS_DE_BORD)
   {
         RS232    rs232_paramètre       //définission de la structure rs232
         //la on renseigne tous les champs de la structure " rs232_paramètre"
         rs232_paramètre.vitesse = XXXXX
         rs232_paramètre.longueur = XXXXX
         rs232_paramètre.truc = XXXXX

        protocole_lecture(& rs232_paramètre) //là on appel le driver en passant la structure en argument
    }

On arrive ensuite dans le driver qui gère le protocole,(init(), open(), lecture(),close(), etc...) qui prend les arguments dont il a besoin dans la structure qu'on lui a passé en argument. Cela implique bien sur que le driver soit développé en fonction!!

On aurai bien sur les fichiers header avec les définitions des structures, les macros utiles pour renseigner les champs des structures misent en jeu.

Cela te parait-il possible à réaliser?

Je me demande aussi si il ne faudrai pas que j'utilise des malloc quand je défini mes strucures, afin de garantir l'espace mémoire. et en oubliant pas de libérer cet espace a chaque fois ??!!!??????

merci JL

[SesechXP]

Pour les paramètres, c'est tout à fait possible. J'ai déjà eu à faire des choses semblables

Par contre les if/else dans la fonction lire risquent de se multiplier et rendre le code illisible. Une structure avec des pointeurs de fonction permettrait de représenter un périphérique et d'en appeler les fonctions sans trop se soucier de son type. Quelque chose dans ce style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
typedef void device__initialize(void* p_parameters);
typedef void device__read(uint8_t* p_data, uint8_t size);
typedef void device__write(uint8_t* p_data, uint8_t size);
typedef void device__close(void);

typedef struct device
{
    device__initialize* p_init;
    device__read*       p_read;
    device__write*      p_write;
    device__close*      p_close;
} device_t;

Chaque périphérique renseigne sa structure et l'expose à la couche "applicative". Et le périphérique se débrouille avec son interface de communication.

Enfin je ne vois pas l'utilité de l'allocation dynamique (malloc, free, etc) pour ton besoin. Il est préférable d'éviter autant que possible. A partir du moment ou la structure qui contient les paramètres est déclarée, la mémoire est allouée.

[JuanLuis]

OK merci pour la piste! Je vais essayer de suivre ça!

Je ne comprends pas par contre comment du coup je peux faire pour envoyer des paramètres différents au driver? Je m'explique. Mio je pensais renseigné les champs de ma structure avec les bonnes valeurs dans ma "couche intermediaire", sachant que mes driver devront recevoir des paramètre différents.
Par exemple entre une liaison SPI et I2C, on envoi pas les même types d'argument et pas le même nombre!

Comment je peux faire alors? j'ai l'impression qu'en utilisant les pointeurs de fonctions j'aurai toujours les même fonctions d'appelées....

Pourrai tu développer un peu ton exemple !!? Et si tu as déja fais ça, il te reste ptet des ptits bouts de code à trainer?!!!

Merci pour ta contribution en tous cas

[SesechXP]

Je ne comprends pas par contre comment du coup je peux faire pour envoyer des paramètres différents au driver? Je m'explique. Mio je pensais renseigné les champs de ma structure avec les bonnes valeurs dans ma "couche intermediaire", sachant que mes driver devront recevoir des paramètre différents.
Par exemple entre une liaison SPI et I2C, on envoi pas les même types d'argument et pas le même nombre!

Si tu peux cacher les paramètres dans le driver, c'est encore mieux ! J'avais cru comprendre que tu voulais que l'applicatif puisse paramétrer les liaisons, d'où mon exemple...

Comment je peux faire alors? j'ai l'impression qu'en utilisant les pointeurs de fonctions j'aurai toujours les même fonctions d'appelées....

Justement, tu peux créer différents périphériques qui sont des variables de type device_t dont les pointeurs de fonction pointent sur la fonction de chaque driver. Par exemple device1.p_init pointera sur device1__initialize, device2.p_init sur device2__initialize, et ainsi de suite...

Pourrai tu développer un peu ton exemple !!? Et si tu as déja fais ça, il te reste ptet des ptits bouts de code à trainer?!!!

Exemple à venir...

[JuanLuis]

J'avais cru comprendre que tu voulais que l'applicatif puisse paramétrer les liaisons, d'où mon exemple...

Non justement je veux un applicatif ultra générique !! mon but est que par la suite on ne touche plus à l'applicatif (pour le projet que je complète).
Ca doit être ma couche intermédiaire qui donne les paramètres utiles au driver. Ma couche intermédiaire ne doit recevoir que le nom du périphérique avec lequel ma liaison se fait et une adresse de donnée ou de sauvegarde suivant le cas!
Ensuite ma couche intermédiaire doit assigner les bonnes valeurs au différents paramètres, qui eux peuvent être différents si c'est de l'I2c, du SPI ou autre d'utilisé!! C'est pour ça que je pensais faire une organisation en if/else.
Si c'est "tel" périphérique alors je donne tel et tel valeurs au driver, si c'est une autre liaison alors je doit donner les valeurs là!
C'est ça que je comprend pas, comment donner ces paramètres au driver de façon dynamique.
C'est pour ça que je pensais envoyer une structure en paramètre. Chaque liaison aurai sa propre structure car chaque liaison a un nombres et des types de paramètres différents!!!
On complète la structure, on l'envoi au driver qui se débrouille a piocher dedans pour trouver son bonheur au moment ou il veut!!

[SesechXP]

OK, du coup je descends la configuration des interfaces dans les drivers de périphériques...

Grosso-modo, j'ai une application qui utilise deux périphériques device1 et device2 :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
#include "device1.h"
#include "device2.h"

#include <stdlib.h>

int main(void)
{
    device1.p_init();
    device2.p_init();

    return EXIT_SUCCESS;
}

représentés par la structure device_t :

Code :

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

1
2
3
4
5
6
7
typedef struct device
{
    device__initialize* p_init;
    device__read*       p_read;
    device__write*      p_write;
    device__close*      p_close;
} device_t;

Les différents membres étant des pointeurs de fonction :

Code :

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

1
2
3
4
typedef void device__initialize(void);
typedef void device__read(uint8_t* p_data, uint8_t size);
typedef void device__write(uint8_t* p_data, uint8_t size);
typedef void device__close(void);

Si on regarde du côté de device1 :
- API :

Code :

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

1
2
3
4
5
6
7
8
#ifndef H__DEVICE1__H
#define H__DEVICE1__H

#include "device.h"

extern const device_t device1;

#endif /* H__DEVICE1__H */

- Implémentation :

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
#include "device1.h"

#include "i2c.h"

#define DEVICE1__ADDRESS 0x55

static void device1__initialize(void);

const device_t device1 =
{
    .p_init = device1__initialize
};

static void device1__initialize(void)
{
    i2c__config_t config =
	{
		.address = DEVICE1__ADDRESS
	};
    i2c__initialize(config);
}

On voit que device1.p_init pointe sur la fonction device1__initialize.

En dessous on trouve l'interface de communication I2C :
- API :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef H__I2C__H
#define H__I2C__H

#include <stdint.h>

typedef struct i2c__config
{
    uint8_t address;
} i2c__config_t;

void i2c__initialize(i2c__config_t config);

#endif /* H__I2C__H */

- Implémentation :

Code :

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

1
2
3
4
5
6
#include "i2c.h"

void i2c__initialize(i2c__config_t config)
{

}

Ci-joint les sources complètes.

++

[JuanLuis]

merci beaucoup pour la réponse et les codes. Je vais étudier ça de plus pret pour essayer d'adapter ça à mon application!
Je reviendrai vers toi si jamais des questions surviennent!!!
Merci encore!

[JuanLuis]

Ok je pense avoir compris le truc! C'est pas mal ça simplifie encore plus les appels dans l'applicatif. moi qui pensais devoir faire par exemple Write(GPS,&Adr), je n'ai plus qu'a faire : GPS.write(&adr) . Enfin ça reviens pratiquement à la meme chose en faite ^^

J'ai compléter un peu le code que tu ma donné! j'ai juste rajouter un write et un read. Pourrai tu jeter un coup d'oeil et me dire si j'ai fait des erreurs. Si je n'ai pas fait d'erreurs je pense avoir compris le mécanisme !

Et en ce qui concerne ces déclarations de fonction :

Code :

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

1
2
static void device1__initialize(void);
static void device1__read(&Adresse_de_sauvegarde);

C'est dans device1.c , on ne doit pas plutôt les mettre dans le device1.h????? Je pense que c'est juste une question d'habitude et que ça ne change rien , mais je préfère demander!!!

Autrement oui j'aime bien cette façon de faire. Ça me permet des appels génériques dans l'applicatif. Ça gère les différences de type et de nombres d'argument qu'on besoin les drivers.

Je vois que dans l'applicatif on inclut les fichiers device1.h et device2.h, pour éviter cela je pensais rassembler tout les fichiers deviceN, dans un deviceN.h et avec des options de précompilation (genre #ifdef SPI ------endif SPI) on pourrai compiler ou pas les liaison dont on a besoin???? et du coup on aurai un seul fichier à inclure dans le main.c !

merci encore! Et je viens de voir qu'on est du 35 tout les deux !!

[SesechXP]

Ok je pense avoir compris le truc! C'est pas mal ça simplifie encore plus les appels dans l'applicatif. moi qui pensais devoir faire par exemple Write(GPS,&Adr), je n'ai plus qu'a faire : GPS.write(&adr) . Enfin ça reviens pratiquement à la meme chose en faite ^^

Tout à fait, ça fait la même chose. Mais tu évites les if/else dans ta couche intermédiaire.

J'ai compléter un peu le code que tu ma donné! j'ai juste rajouter un write et un read. Pourrai tu jeter un coup d'oeil et me dire si j'ai fait des erreurs. Si je n'ai pas fait d'erreurs je pense avoir compris le mécanisme !

Pas d'erreur, cependant dans les drivers i2c et spi, je ne passerais par de structures i2c__config ou spi__config. A priori la configuration a déjà été faite lors de l'initialisation. Il est donc inutile de repasser tout ça. Ce dont a besoin la fonction i2c__read, c'est juste une adresse où lire des données et peut-être un buffer dans lequel mettre les données lues. Quelque chose dans ce genre :

Code :

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

i2c__read(address, buffer);

Et en ce qui concerne ces déclarations de fonction :

Code :

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

1
2
static void device1__initialize(void);
static void device1__read(&Adresse_de_sauvegarde);

C'est dans device1.c , on ne doit pas plutôt les mettre dans le device1.h????? Je pense que c'est juste une question d'habitude et que ça ne change rien , mais je préfère demander!!!

En effet, question d'habitude... On peut très bien mettre les prototypes de fonctions dans le fichier d'entête. Mais j'ai choisi de ne pas le faire et d'obliger à accéder au périphérique via la structure et donc avec les pointeurs sur fonction.

Je vois que dans l'applicatif on inclut les fichiers device1.h et device2.h, pour éviter cela je pensais rassembler tout les fichiers deviceN, dans un deviceN.h et avec des options de précompilation (genre #ifdef SPI ------endif SPI) on pourrai compiler ou pas les liaison dont on a besoin???? et du coup on aurai un seul fichier à inclure dans le main.c !

Tout dépend de ton projet... J'ai fais ainsi comme pour les miens parce que selon les configurations je n'ai pas les mêmes périphériques ni les mêmes liaisons. Fait comme tu le sens et surtout en fonction de ton projet...

merci encore! Et je viens de voir qu'on est du 35 tout les deux !!

Au plaisir

[JuanLuis]

Tout dépend de ton projet... J'ai fais ainsi comme pour les miens parce que selon les configurations je n'ai pas les mêmes périphériques ni les mêmes liaisons. Fait comme tu le sens et surtout en fonction de ton projet...

Etant donné que je travail sur de l'embarqué, sur PIC, je n'ai pas plus que ça d'espace mémoire, et comme le but à l'avenir est de compléter cette couche pour qu'elle puisse gérer X communications, j'aimerai bien ne pas me trainer tous le code qui ne servira pas dans tel ou tel projet. Si il y en a un qui n'utilise pas la liaison SPI, à quoi bon compiler la partie correspondante!
En y repensant là, c vrai que je peux tous garder dans des fichiers séparés, rien n'empêche d'utiliser les instructions de précompilation !!!

Merci pour toute cette aide! Je pense que je peux clore ce post