LOCODUINO

Forum de discussion
Dépôt GIT Locoduino
Flux RSS

vendredi 23 juin 2017

32 visiteurs en ce moment

Le monde des objets (2)

Des objets partout !

. Par : Dominique, Thierry

Nous avons introduit dans l’article précédent la programmation « objet » dans l’IDE Arduino, les principes du C++ et ses avantages. Continuons d’en explorer les affriolantes capacités.

Visibilité, encapsulation

Nous allons maintenant développer une petite classe qui va nous servir d’exemple très simple à comprendre, mais qui fera partie d’un ensemble plus ambitieux dans les chapitres suivants…

Imaginons une Led, qui doit être initialisée avec un numéro de broche et qui peut s’allumer et s’éteindre, donc avec une variable qui stockera son état. Le clignotement est un développement ultérieur possible…

La déclaration pourrait ressembler à ça :

  1. class Led
  2. {
  3. // Données
  4. byte pin;
  5. byte etat;
  6. // Méthodes
  7. void Setup(byte aPin); // initialisation de la broche pour la led.
  8. void Allumer();
  9. void Eteindre();
  10. };

pin stocke le numéro de broche dont on aura besoin à chaque changement d’état, lequel est mémorisé dans etat. Les trois méthodes Setup() Allumer() et Eteindre() permettent respectivement d’initialiser la classe et ses données, d’allumer ou d’éteindre la diode.

Petite remarque syntaxique : le ’;’ est vraiment important à la fin de la définition de la classe. Il est obligatoire, tout comme pour un enum ou un struct en C.

Comme nous l’avons vu dans le premier chapitre, l’encapsulation consiste à regrouper sous un même nom tout ce qui concerne un type d’objet, données et méthodes. Il permet également de ne laisser accessible que ce qui doit l’être vu de l’extérieur. Il y a trois niveau de protection du contenu d’une classe : privé, protégé et public.

  • Si rien n’est précisé comme dans notre exemple Led, tout est privé. CE qui est privé n’est visible que des objets de la classe elle même. Cela veut dire par exemple que cette première version de la classe ne peut pas fonctionner. Tout est privé, ce qui empêche quiconque d’accéder aux méthodes Setup() Allumer() et Eteindre() ! Voilà une classe qui perd un peu de son intérêt.
  • Ce qui est déclaré protected (protégé) est visible par la classe elle même, mais aussi par les classes dérivées, concept que nous aborderons un peu plus tard.
  • Enfin les éléments publics sont visibles par tous.

Ce sont les rôles de deux nouveaux mot-clés private et public illustrés dans la classe Led.

  1. class Led
  2. {
  3. private:
  4. byte pin;
  5. byte etat;
  6.  
  7. public:
  8. void Setup(byte aPin); // initialisation de la broche pour la led.
  9. void Allumer();
  10. void Eteindre();
  11. };

Leur sens est évident : private cache les données et les méthodes aux yeux du monde, mis à part les objets de la classe Led, et public les rend visibles et modifiables par tout le monde.
Par exemple si on utilise la classe Led ci-dessus, le code suivant est incorrect :

  1. setup() // setup général du .ino
  2. {
  3. Led maled;
  4. maled.pin = 10; // Erreur de compilation, pin n'est pas accessible.
  5. }

Ce qui est logique ici, puisque l’on veut que l’utilisateur de la classe passe forcément par Setup() pour être sûr de bien initialiser la broche… Notez l’utilisation du ’.’ pour accéder aux membres d’un exemplaire de la classe comme ’maled’ ici. C’est la même syntaxe, le même principe que pour une structure.

Allons plus loin. Pour une DEL  , selon la façon dont elle est câblée, un état haut (HIGH) de la broche peut l’allumer ou l’éteindre ! Voir notamment à la fin de l’article consacré aux leds.

Pour que le classe Led fonctionne dans les deux cas, il faut définir le type de montage de la led : normal (broche reliée à l’anode et fournissant le courant) ou inversé (broche reliée à la cathode et absorbant le courant), afin d’être sûr que lorsque l’on appelle la méthode Allumer(), le résultat est bien celui espéré… Pour simplifier le codage, passons alors par une fonction privée Rafraichir qui fera l’interprétation voulue.

  1. /// Déclaration de la classe Led
  2.  
  3. class Led
  4. {
  5. private:
  6. byte pin;
  7. byte etat; // HIGH pour allumé, LOW pour éteint,
  8. // quelque soit la valeur de montageInverse
  9. bool montageInverse; // true si il faut LOW pour allumer !
  10. void Rafraichir();
  11.  
  12. public:
  13. void Setup(byte aPin, bool aMontageInverse = false); // initialisation de la broche
  14. // pour la led.
  15. void Allumer();
  16. void Eteindre();
  17. };
  18.  
  19. // Définition des méthodes.
  20. void Led::Setup(byte aPin, bool aMontageInverse )
  21. {
  22. montageInverse = aMontageInverse ;
  23. pin = aPin;
  24. pinMode(aPin, OUTPUT);
  25.  
  26. // Commençons diode éteinte...
  27. Eteindre();
  28. }
  29.  
  30. void Led::Allumer()
  31. {
  32. etat = HIGH; // Allumé
  33. Rafraichir();
  34. }
  35.  
  36. void Led::Eteindre()
  37. {
  38. etat = LOW; // Eteint
  39. Rafraichir();
  40. }
  41.  
  42. void Led::Rafraichir()
  43. {
  44. byte vraiEtat = etat; // on prend l'état demandé
  45. if (aMontageInverse == true) // si c'est un montage inversé
  46. vraiEtat = ! vraiEtat; // on inverse
  47. digitalWrite(pin, vraiEtat);
  48. }
  49.  
  50. // Programme Arduino
  51.  
  52. Led maled;
  53.  
  54. void setup()
  55. {
  56. maled.Setup(10, false);
  57. }

Petite remarque syntaxique : la compilation du source commence en haut, et va vers le bas. Il est donc important que la déclaration précède la définition. En clair, la définition des méthodes doit se faire après la déclaration de la classe !

Les méthodes Allumer() et Eteindre() se contentent de mettre à jour etat, puis la méthode privée Rafraichir() est appelée et s’occupe de modifier l’état matériel de la broche en fonction de l’état demandé et du type de montage. Noter la valeur par défaut de l’argument dans la déclaration de la méthode Setup :

void Setup(byte aPin, bool aMontageInverse = false);

Le fait de donner une valeur initiale à aMontageInverse permet d’omettre cet argument en appelant Setup() quand sa valeur est false. Cela permet d’écrire soit maled.Setup(10); et aMontageInverse est initialisé automatiquement à false, soit maled.Setup(10, false);, sinon il faut spécifier un état inverse avec maled.Setup(10, true);.

Résultat de tout cela, on a ajouté une fonctionnalité à la classe sans toucher au reste du programme, et avec l’assurance d’un minimum de perturbations. Personne n’a besoin de savoir comment se fait le changement d’état, ni quelle méthode a été appelée. Rendre privé une partie du code et des données rend l’objet plus simple vu de l’extérieur, malgré une complexité intérieure qui peut être très importante. L’interface avec le reste du code reste humainement compréhensible…

On pourrait écrire la méthode privée Rafraichir() de cette autre façon :

  1. void Led::Rafraichir()
  2. {
  3. digitalWrite(pin, Etat ^ aMontageInverse);
  4. }

^ est l’opérateur du OU Exclusif qui donne les résultats suivants :

Etat aMontageInverse résultat
1 (HIGH) 1 (true) 0 (LOW)
1 (HIGH) 0 (false) 1 (HIGH)
0 (LOW) 1 (true) 1 (HIGH)
0 (LOW) 0 (false) 0 (LOW)

Reportez-vous à « Calculer avec l’Arduino (2) » pour des informations complémentaires sur le OU Exclusif.

Constructeurs…

Une classe n’est pas un objet. Ce serait un peu comme dire que la table des matières est le livre ! Une classe, c’est la description de ce qu’un objet de ce type doit contenir et comment il doit se comporter. A un moment, il faut donc créer l’objet proprement dit, c’est à dire mettre en place en mémoire les variables de l’objet et les initialiser. On parle d’instanciation.

Ainsi lorsque l’on écrit

Led maled;

on fait appel implicitement à une fonction très particulière : le constructeur. C’est la première méthode de l’objet à être exécutée. La définition de cette méthode spéciale n’est pas obligatoire (si vous ne souhaitez pas initialiser les données par exemple) dans la mesure où une version par défaut de ce constructeur sans arguments existe toujours, automatiquement créée par le compilateur si elle n’est pas fournie par le programmeur, mais dans ce cas le contenu des données membres de l’objet créé est indéterminé. Typiquement, les entiers ne contiendront pas forcément 0 après la création de l’objet, mais plutôt n’importe quoi !

Cette méthode particulière est facilement identifiée par le fait que son nom est celui de la classe, et qu’elle n’accepte pas de valeur de retour :

  1. class Led
  2. {
  3. private:
  4. byte pin;
  5. byte etat;
  6. bool montageInverse;
  7. void Rafraichir();
  8.  
  9. public:
  10. Led(); // Constructeur
  11.  
  12. void Setup(byte aPin, bool aMontageInverse = false); // initialisation de la broche
  13. // pour la led.
  14. void Allumer();
  15. void Eteindre();
  16. };
  17.  
  18. Led::Led()
  19. {
  20. pin = 0;
  21. Eteindre();
  22. }

Plutôt que d’avoir un constructeur qui va tout mettre à 0, puis un Setup qui va vraiment faire l’initialisation, répartissons mieux les rôles. On peut ajouter à la classe un constructeur avec des arguments :

  1. Led(int aPin, bool aMontageInverse = false)
  2. {
  3. pin = aPin;
  4. montageInverse = aMontageInverse;
  5. }
  6.  
  7. void Led::Setup()
  8. {
  9. pinMode(pin, OUTPUT);
  10.  
  11. Eteindre();
  12. }

L’initialisation d’une nouvelle instance est ainsi modifiée :

  1. Led maled(10);
  2. maled.Setup();

Les rôles sont mieux répartis entre le constructeur qui remplit les variables locales de la classe, et le Setup() qui les utilise pour initialiser l’objet au bon moment.

… et destructeurs

Par symétrie avec le constructeur, il y a aussi un destructeur optionnel, dont le nom commence par un caractère ~ (ça se prononce ’tilde’ en français). Il suffit de savoir que c’est possible en C++, même si son usage est assez limité sur Arduino.

Code complet

Avant de clore ce chapitre, voici le code complet de la petite classe Led :

  1. /// Déclaration de la classe Led
  2.  
  3. class Led
  4. {
  5. private:
  6. byte pin;
  7. byte etat; // HIGH pour allumé, LOW pour éteint,
  8. // quelque soit la valeur de montageInverse
  9. bool montageInverse; // true si il faut LOW pour allumer !
  10. void Rafraichir();
  11.  
  12. public:
  13. Led(byte aPin, bool aMontageInverse = false); // constructeur complet
  14. void Setup();
  15. void Allumer();
  16. void Eteindre();
  17. };
  18.  
  19. // Définition des méthodes. Par convention, on commence par le constructeur
  20. Led::Led(byte aPin, bool aMontageInverse)
  21. {
  22. pin = aPin;
  23. montageInverse = aMontageInverse;
  24. }
  25.  
  26. // Et le reste, dans l'ordre de définition de la classe pour s'y retrouver...
  27. void Led::Setup()
  28. {
  29. pinMode(pin, OUTPUT);
  30. // Je décide de commencer dans un état éteint...
  31. Eteindre();
  32. }
  33.  
  34. void Led::Allumer()
  35. {
  36. etat = HIGH; // Allumé
  37. Rafraichir();
  38. }
  39.  
  40. void Led::Eteindre()
  41. {
  42. etat = LOW; // Eteint
  43. Rafraichir();
  44. }
  45.  
  46. void Led::Rafraichir()
  47. {
  48. byte vraiEtat = etat; // on prend l'état demandé
  49. if (montageInverse == true) // si c'est un montage inversé
  50. vraiEtat = ! vraiEtat; // on inverse
  51. digitalWrite(pin, vraiEtat);
  52.  
  53. // ou la ligne unique suivante :
  54. // digitalWrite(pin, Etat ^ aMontageInverse);
  55. }
  56. /// Fin de la classe Led
  57.  
  58. /// Partie classique du Sketch
  59. // On crée 2 leds
  60. Led rouge(10); // pin 10
  61. Led verte(11); // pin 11
  62.  
  63. void setup()
  64. {
  65. rouge.Setup();
  66. verte.Setup();
  67. }
  68.  
  69. void loop()
  70. {
  71. rouge.Allumer();
  72. delay(1000);
  73. rouge.Eteindre();
  74. delay(1000);
  75. verte.Allumer();
  76. delay(1000);
  77. verte.Eteindre();
  78. delay(1000);
  79. }

Télécharger

Le premier gain de ce type d’écriture C++, c’est la lisibilité du code. La partie croquis classique setup+loop est vraiment réduite à l’essentiel et se concentre sur le comportement général. Le vieux proverbe ’Diviser pour régner’ est très utilisé en informatique et permet de simplifier les problèmes complexes en les réduisant en somme de problèmes simples. C’est exactement ce que permet l’objet et réduisant les méthodes à des rôles très simples. L’assemblage dans le croquis devient limpide !

Un autre avantage est la réutilisation. Au delà de la création de bibliothèque qui pourrait reprendre la classe, il est très simple de transférer Led dans un autre croquis. On est sûr de ne pas en emmener trop, et au pire le nettoyage (enlever le traitement du montage inverse, par exemple) n’est pas compliqué.

Enfin, et contrairement à une idée répandue, un gain de mémoire programme est très probable. Le principe de dérivation dont il sera question dans le troisième volet pousse à une réutilisation du code existant et à une rationalisation des données. Il en résulte souvent une économie notable pour la mémoire programme. Par contre, la mémoire vive, la SRAM, peut être impactée par les fonctions virtuelles, mais ça c’est une autre histoire !

Si c’est toujours clair, nous pourrons passer au chapitre suivant. Sinon, reprenez depuis le début !

4 Messages

Réagissez à « Le monde des objets (2) »

Qui êtes-vous ?
Votre message

Pour créer des paragraphes, laissez simplement des lignes vides.

Lien hypertexte

(Si votre message se réfère à un article publié sur le Web, ou à une page fournissant plus d’informations, vous pouvez indiquer ci-après le titre de la page et son adresse.)

Rubrique « Programmation »

Comment gérer le temps dans un programme ?

La programmation, qu’est ce que c’est

Types, constantes et variables

Installation de l’IDE Arduino

Répéter des instructions : les boucles

Les interruptions (1)

Instructions conditionnelles : le if … else

Instructions conditionnelles : le switch … case

Comment gérer l’aléatoire ?

Calculer avec l’Arduino (1)

Calculer avec l’Arduino (2)

Les structures

Systèmes de numération

Les fonctions

Trois façons de déclarer des constantes

Transcription d’un programme simple en programmation objet

Les chaînes de caractères

Trucs, astuces et choses à ne pas faire !

Les pointeurs (1)

Les pointeurs (2)

Les Timers (I)

Les Timers (II)

Les Timers (III)

Les Timers (IV)

Les Timers (V)

Bien utiliser l’IDE d’Arduino (1)

Bien utiliser l’IDE d’Arduino (2)

Les derniers articles

Bien utiliser l’IDE d’Arduino (2)


Thierry

Bien utiliser l’IDE d’Arduino (1)


Christian Bézanger, Dominique, Jean-Luc, Thierry

Les Timers (V)


Christian Bézanger

Trucs, astuces et choses à ne pas faire !


Dominique

Le monde des objets (4)


Thierry

Les pointeurs (2)


Thierry

Les chaînes de caractères


Thierry

Transcription d’un programme simple en programmation objet


Dominique, Guillaume, Jean-Luc

Les pointeurs (1)


Thierry

Comment gérer l’aléatoire ?


Dominique, Guillaume, Jean-Luc

Les articles les plus lus

Les interruptions (1)

Les Timers (I)

Calculer avec l’Arduino (1)

Les Timers (III)

Comment gérer le temps dans un programme ?

Les Timers (IV)

Installation de l’IDE Arduino

La programmation, qu’est ce que c’est

Les Timers (II)

Calculer avec l’Arduino (2)