Librairie domotique: Les entrées/sorties

Commençons par le début, les entrées/sorties: l’arduino possède des io digitales et analogiques au nombre d’environ 20 à 70 suivant les modèles.

Les io digitales peuvent être configurées en entrée ou en sortie. Les entrées analogiques, elles, restent des entrées mais peuvent être utilisées comme entrées digitales avec les id 14 à 19 pour l’arduino uno et 54 à 70 pour l’arduino mega.

[adsGrandRectangleTexte]

Je vais vous expliquer comment sont définies est utilisées les entrées/sorties dans la libraire connectingStuff. Gardons à l’esprit que ce ne sont que des exemples et qu’en règle générale nous ne manipulerons pas ces classes directement dans le sketch.
Elles sont utilisées par d’autres classes, celles qui définissent les modules, comme des interrupteurs, lumières, etc…

Les entrées

Les entrées sont représentées par la classe Input. Elles sont définies par un numéro d’io et un état courant (Une valeur entre 0 et 255). Nous allons y ajouter un état précédant qui nous servira à détecter si les changements d’états sont montants ou descendants.
La classe contient du code anti-rebond permettant de filtrer l’entrée. Voir le tutorial Debounce sur arduino.cc pour plus d’explications.

La classe Input :

class Input
{
  protected:
    uint8_t m_iio;            // Numero d'io

    uint8_t m_iState;         // Etat courant
    uint8_t m_iLastState;     // Etat precedent

    Timer m_TimerDebounce;    // AntiRebond (voir tuto sur arduino.cc)
    bool m_bDebounceInput;

    uint8_t Read();           // Retourne la valeur de l'io
 public:
    Input();
    Input(int, bool = true);
    ~Input();

    void Init(int, bool = true); // io, debounce: true/false

    uint8_t GetState();          // Retourne l'état courant
    uint8_t GetLastState();      // Retourne l'état précédant
    bool StateChange();          // Retourne true en cas de changement d'état

    void SetInternalPullupResistor(); // Positionne la résistance de Pullup interne
};

Les sorties

Dans l’article de présentation de la librairie je vous ai dis que le système peut être constitué de plusieurs cartes Arduino et qu’une entrée d’une carte peut/pourra piloter une sortie d’une autre carte.
Il va donc falloir donner un ID unique à chaque carte du système et chaque sortie sera identifiée par une concaténation de l’ID de sa carte et du numéro de l’io utilisée sur celle-ci.
Par exemple, pour l’io 2 de la carte 1 l’ID de la sortie sera : 1*100+2 = 102, ce qui permet de gérer 100 io par carte.

La classe Output :

class Output
{
  protected:
    uint8_t m_iCard;          // L'Id de la carte
    uint8_t m_iio;            // Numero de l'io
    int m_iID;                // L'Id unique de la sortie sur le reseau

    uint8_t m_iState;         // Etat de la sortie

    Timer m_OnTimer;          // Tps d'activite depuis le dernier On

  public:
    Output();
    Output(uint8_t, uint8_t); // id carte, io
    ~Output();

    void Init(uint8_t, uint8_t);

    void Set(uint8_t);        // Positionne la sortie
    void Toogle();            // Bascule la sortie sur HIGH/LOW

    uint8_t Read(void);       // Retourne l'etat de la sortie

    uint8_t GetCardID();      // Retourne l'id de la Carte sur laquelle se trouve
                              // la sortie
    int GetID();              // Retourne l'id unique de la sortie

    unsigned long GetOnTime(void); // Retourne le temps d'activite
};

La classe possède un timer permettant de savoir combien de temps la sortie est restée active. La méthode GetOnTime() permet de récupérer la valeur du timer.
Ça peut être utile pour faire un calcul approximatif de consommation d’une lampe, truc commandé par cette io par exemple.

Exemples

Exemple d’utilisation avec une sortie seule qui est basculée toutes les secondes :

#include <ConnectingStuff.h>

// Définition d'une sortie
Output sortie;

void setup()
{
  // Définit l'ID unique de la carte sur le réseau
  ConnectingStuff::SetCARDID(1, "carte1");

  // Initialisation de la sortie de la carte 1, io 13
  sortie.Init(1,13);
}

void loop()
{
  // Bascule l'état de la sortie toutes les secondes
  sortie.Toogle();
  delay(1000);
}

Exemple d’interaction entre une entrée et une sortie :

#include <ConnectingStuff.h>

// Définition d'une sortie
Input entree;
Output sortie;

void setup()
{
  // Définit l'ID unique de la carte sur le réseau
  ConnectingStuff::SetCARDID(1, "carte1");

  // Initialisation de l'entrée 2
  entree.Init(2);
  entree.SetInternalPullupResistor();

  // Initialisation de la sortie de la carte 1, io 13
  sortie.Init(1,13);
}

void loop()
{
  entree.Read();

  // Bascule la sortie à chaque changement d'état de l'entrée
  if(entree.StateChange())
  {
    sortie.Toogle();
  }
}

Partagez moi ...Tweet about this on TwitterShare on Facebook0Share on Google+0Digg thisEmail this to someone

Vous aimerez aussi...

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *