Dans cet article, nous allons comment rendre sa boîte à lettres connectée, le tout à base d’Arduino Pro Mini et d’IPX800 afin d’être informé de la présence de courrier mais également du statut d’ouverture de la porte et du clapet.

Présentation

Avant de rentrer dans les détails de cet article et de vous présenter ma solution, je tiens avant tout de rendre à César ce qui lui appartient concernant la partie aménagement intérieur de la boîte à lettres et à en remercier chaleureusement son auteur : Créer une boite aux lettres connectée.

Le montage en plusieurs parties démontables à l’intérieur de la boîte est vraiment très bien pensé !

C’est d’ailleurs pourquoi nous ne verrons pas ici la partie aménagement de la dîtes boîte car elle reprend exactement le même principe de montage que celui cité dans l’article, cependant nous allons nous épancher ici un peu plus sur le choix du matériel, de la partie électronique, de la programmation logicielle ainsi que l’ajout de quelques fonctionnalités intéressantes.

Dans mon cahier des charges personnel, et à l’instar de l’article cité précédemment, l’idée de la détection de courrier par obturation de photodiode était déjà de vigueur (comme beaucoup de montage de ce style) mais je souhaitais également y coupler une détection d’ouverture du clapet et de la porte de ma boîte à lettres afin de pouvoir éventuellement différencier le colis de la lettre et remonter les statistiques de dépose/relève de courrier (mais de manière indépendante).

Autre précision : je souhaitais une solution 100% filaire, ceci évidemment car j’ai la chance d’avoir un fourreau directement accessible de ma boîte à lettres à mon garage où est hébergé mon IPX800.

Il est également tout à fait possible de pousser le vice jusqu’à y mettre une mini-caméra afin de pouvoir contrôler le contenu de la boîte mais ce sujet ne sera pas de rigueur ici (…pour l’instant).

Voici quelles étaient mes attentes :

• L’alimentation de l’automate et la remontée de l’information doivent se faire en filaire (oui je suis fan de ce type de raccordement quand faire se peut, au détriment du sans-fil et le fait d’être dépendant de l’autonomie par batterie).

• La remontée de l’information entre l’IPX et l’automate doit être faîte au plus bas niveau possible, donc exit l’idée de la prise ethernet (et de mon réseau domotique) accessible depuis la rue ou autre “Shield” à intégrer sur l’automate alourdissant le montage, tout doit être effectuée en signal analogique via l’envoi d’une tension définie depuis l’automate selon les scénarios possibles.

• On doit remonter plusieurs informations via le signal analogique : l’ouverture/fermeture du clapet, l’ouverture/fermeture de la porte (permettant de différencier la dépose de lettre ou de colis) ainsi que la présence/relève de courrier.

• Le système de vérification du contenu de la boîte à lettres doit pouvoir être à la fois activé par celui de détection d’ouverte/fermeture clapet/porte afin de s’enclencher après une interaction de ces derniers mais également autonome via une vérification à intervalle régulier en cas de défaillance du système d’ouverture ou lors du démarrage de l’automate.

• Signaux lumineux (LED) derrière la boite à lettres afin d’informer “physiquement” de la présence de courrier et des états des ouvertures clapet/porte lorsqu’elles sont déclenchées.

Voici un petit aperçu du rendu final :

Pré-requis matériel

• Un automate ATMEGA328P 3.3V 8M (Arduino Pro Mini ou clone) dans sa version 3,3v (avec Adaptateur USB – TTL série si vous n’en possédez pas).
• Quelques résistances :
  • 6 de 150 Ω
  • 2 de 220 Ω
  • 1 de 10 kΩ
  • 2 de 100 kΩ
  • 1 de 220 kΩ
  • 1 de 470 kΩ
• 2 interrupteurs magnétique (switch reed) pour la détection d’ouverture/fermeture du couple clapet/porte.
• 2 aimants.
• 6 LED 5 mm 940 nm infrarouge.
• 6 photodiodes.
• Cartes de prototypage pour accueillir les différents montages électronique.
• Différents connecteurs JST mâle et femelle (pour la connexion entre le câble arrivant de l’IPX et l’automate).
• 1 boitier de dérivation électrique étanche.
• En vrac : de la gaine thermorétractable, du fil d’étain, un fer à souder, du câble pour la liaison des différents composants…

Montage électronique

Voici le schéma de montage des différents composants électronique de la solution :

Quelques petites remarques par rapport à ce montage sont de rigueur.

Comme vous pourrez le constater, les photodiodes sont montées “à l’envers”, c’est à dire que la polarisation est inversée. Ceci couplé avec une résistance de forte valeur (ici 10 kΩ) nous donnera de meilleurs résultats (dans mon cas).

Les interrupteurs magnétiques ne sont pas reliés à des résistances (dîtes de “Pull-up”) sur le schéma, ceci étant dû au fait que l’Arduino possède déjà cette résistance en interne : il suffit de lui indiquer dans le code de l’automate que nous souhaitons utiliser sa résistance interne sur les pins où sont reliés ces interrupteurs.

Chacun des pins D10/11/12 sont reliés à des résistances de valeur différentes : il s’agit ici d’un pont diviseur de tension. En effet ces pins, comme nous le verrons ci-après, servent à émettre le signal analogique envoyé à l’IPX en indiquant respectivement l’état du clapet, de la porte ou de la présence de courrier. Or comme l’automate ne possède pas de sortie analogique à proprement parlé, ils ne peuvent agir qu’en sortie numérique : ON (+3.3v) ou OFF (0v) ne permettant donc pas d’indiquer les différents états voulus. Ce pont diviseur de tension va nous le permettre en rendant cette tension différente et unique grâce aux résistances en amont en fonction des pins activés. Il suffira alors d’indiquer à l’IPX quelle est la correspondance de ces différentes valeurs en fonction du signal analogique reçu.

L’alimentation de l’automate se fait directement via le pin d’entrée VCC et non RAW car nous ne souhaitons pas utiliser le régulateur de tension interne à l’automate, la tension d’entrée (fourni par l’IPX) étant déjà de 3.3v.

Programmation de l’automate

Avant de vous livrer le code, voici un petit schéma expliquant son fonctionnement.

Sans plus attendre, voici le code à insérer dans l’Arduino (cliquez ci-dessous pour l’afficher).

  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
144
145
146
147
148
149
150
151
152
153
154
155
156

// Bibliothèque pour la gestion des rebonds des reed switch
#include <Bounce2.h>
// Photodiode pins
const byte photodiodeArray[6] = {2,3,4,5,6,7}; // Tableau de la liste des pins des photodiodes
const int photodiodeArraySize = sizeof(photodiodeArray); // Defini la taille du tableau des pins des photodiodes
// Reed switch pins
#define REED_VALVE 8
#define REED_DOOR 9
// State pins
#define STATE_MAIL 10
#define STATE_DOOR 11
#define STATE_VALVE 12
// LED pins
#define LEDS_IR A0
#define LED_MAIL A1
#define LED_REED A2
// Sensor pins
#define SENSOR_PHOTODIODE A3
// Objets pour le bounce des reed switchs
Bounce rebond_valve;
Bounce rebond_door;
// Defini le seuil de sensibilité des photodiodes à partir duquel déclencher les actions
#define mailThreshold 10
int valveValue = 0; // Variable l'etat d'ouverture de la valve
int doorValue = 0; // Variable pour l'état d'ouverture de la porte
int valveStatus = 0; // Variable pour stocker l'état de la valve
int doorStatus = 0; // Variable pour stocker l'état de la porte
int mailStatus = 0; // Variable pour indiquer la présence de courrier
int mailboxAction = 1; // Variable pour indiquer que la véréifcation de la boite doit être faites ou non. Est à 1 au lancement du programme afin de lancer le processus au démarrage de l'automate.
int checkAction = 0; // Variable pour indiquer si une action de vérification de la boîte à lettres est nécessaire ou non.
unsigned long mailboxclosedMillis = 0; // Variable utilisée pour calculer l'intervalle de la derniere fermeture du clapet ou de la porte
unsigned long mailboxcheckMillis = 0; // Variable utilisée pour calculer l'intervalle de la derniere vérification de la boite à lettres
const long interval = 10000; // Intervalle de vérification de la boite à lettres (en ms) après détection de mouvements du calpet ou de la porte
const long check = 1800000; // Intervalle périodique de vérification de la boite à lettres quand aucune activité n'a été détectée
void setup() {
  // Serial initialization
  Serial.begin(9600);
  // Définition des pins
  for (int i=0; i<photodiodeArraySize; i++) {
    pinMode (photodiodeArray[i], OUTPUT);
  }
 
  pinMode(REED_VALVE, INPUT_PULLUP);
  pinMode(REED_DOOR, INPUT_PULLUP);
  pinMode(STATE_VALVE, OUTPUT);
  pinMode(STATE_DOOR, OUTPUT);
  pinMode(STATE_MAIL, OUTPUT);
  pinMode(LEDS_IR, OUTPUT);
  pinMode(LED_MAIL, OUTPUT);
  pinMode(LED_REED, OUTPUT);
  pinMode(SENSOR_PHOTODIODE, INPUT);
  // Définition des objets
  rebond_valve.attach(REED_VALVE);
  rebond_door.attach(REED_DOOR);
  rebond_valve.interval(10);
  rebond_door.interval(10);
}
void loop()
{
  // ### DETECTION ACTIVITE CLAPET ET PORTE
  // Maj de la valeur des rebonds pour les switch reeds
  rebond_valve.update();
  rebond_door.update();
  // Lecture valeur des rebonds
  int valveValue = rebond_valve.read();
  int doorValue = rebond_door.read();
  // Detecte si l'état d'ouverture de la valve à changé.
  if (valveStatus < valveValue)
  {
    Serial.println((String)"La valve s'est ouverte");
    digitalWrite(LED_REED, HIGH);
    digitalWrite(STATE_VALVE, HIGH);
    valveStatus = 1;
  } else if (valveStatus > valveValue)
  {
    Serial.println((String)"La valve s'est fermée");
    if (!doorStatus)
    {
      digitalWrite(LED_REED, LOW);
    }
    digitalWrite(STATE_VALVE, LOW);
    mailboxclosedMillis = millis();
    valveStatus = 0;
    mailboxAction = 1;
  }
  // Detecte si l'état d'ouverture de la porte à changé.
  if (doorStatus < doorValue)
  {
    Serial.println((String)"La porte s'est ouverte");
    digitalWrite(LED_REED, HIGH);
    digitalWrite(STATE_DOOR, HIGH);
    doorStatus = 1;
  } else if (doorStatus > doorValue)
  {
    Serial.println((String)"La porte s'est fermée");
    if (!valveStatus)
    {
      digitalWrite(LED_REED, LOW);
    }
    digitalWrite(STATE_DOOR, LOW);
    mailboxclosedMillis = millis();
    doorStatus = 0;
    mailboxAction = 1;
  }
  // ### VERIFICATION DE LA BOITE A LETTRES
  if (millis() - mailboxcheckMillis >= check)
  {
     Serial.println((String)"Le temps maximum s'est écoulé depuis la dernière vérification. Vérification la boite à nouveau.");
     checkAction = 1;
  }
  if(millis() - mailboxclosedMillis >= interval)
  {
    if ((mailboxAction && !doorStatus && !valveStatus) || checkAction)
    {
      Serial.println((String)"Vérification de la boite.");
      Serial.println((String)"Allumage IR LEDS");
      digitalWrite(LEDS_IR, HIGH);
      for (int i=0; i<photodiodeArraySize; i++) {
        Serial.println((String)"Vérification photodiode "+i);
        mailStatus = checkMailbox(photodiodeArray[i]);
        if (mailStatus) {
          break;
        }
      }
      Serial.println((String)"Extinction IR LEDS");
      digitalWrite(LEDS_IR, LOW);
      if (mailStatus) {
        Serial.println((String)"Allumage LED_MAIL");
        digitalWrite(LED_MAIL, HIGH);
        digitalWrite(STATE_MAIL, HIGH);
      } else {
        Serial.println((String)"Extinction LED_MAIL");
        digitalWrite(LED_MAIL, LOW);
        digitalWrite(STATE_MAIL, LOW);
      }
      mailboxcheckMillis = millis();
      mailboxAction = 0;
      checkAction = 0;
      Serial.println((String)"Fin de la vérification");
    }
  }
  delay(20);
}
bool checkMailbox(uint8_t photodiode)
{
  // Allumage de la photodiode
  digitalWrite(photodiode, HIGH);
  // Attente pour stabilisation de la photodiode
  delay(1000);
  // Lecture de la valeur de la photodiode
  int measure = analogRead(SENSOR_PHOTODIODE);
  // Arret de l'alimentation de la photodiode.
  digitalWrite(photodiode, LOW);
  // Envoi de la valeur si seuil atteint
  return measure < mailThreshold;
}

Comme vous pourrez le constater, j’ai utilisé ici une bibliothèque nommée Bounce2 (que vous devrez installer via votre IDE avant le téléversement du code sur l’automate).

Cette bibliothèque permet “d’effacer” logiciellement les rebonds des interrupteurs magnétiques pouvant provoquer de faux positifs.

Quelques explication sur le phénomène ici.

Note : il aurait également été possible de pallier à cet effets de rebonds matériellement via la mise en place de condensateurs entre les bornes des interrupteurs magnétique, cependant trouver la bonne valeurs pour ces condensateurs se relève plus hasardeuse et complexe.

Tableau de correspondance des valeurs analogiques

Voici le tableau de correspondance des valeurs analogique relevées à chaque action possible sur la boîte en fonction de ses différents capteurs embarqués.

Celles-ci ont été mesurées en amont de la résistance R-D-4, soit directement sur la liaison qui sera raccordée à l’entrée analogique de l’IPX.

Configuration de l’IPX

Sorties Virtuelles

Création de sorties virtuelles pour la gestion des capteurs de la boîte à lettres (Menu Périphériques -> Sorties Virtuelles).

Compteurs

Création de compteurs pour comptage des évènements (Menu Périphériques -> Compteurs).

Scenarios

Voici la liste des scénarios à configurer pour la gestion de la boîte à lettres. Le détails de ces scénarios est expliqué ci-après.

Note : L’ordre des scénario est important ! En effet, ces derniers sont exécutés de manière séquentielle, ce qui veut dire que le programme interne de l’IPX va parcourir l’ensemble des scénarios les uns après les autres dans l’ordre de la liste et les exécuter en fonction de cet ordre. Donc si 2 scénarios se contredisent, seul le dernier scénario sera pris en compte.

Explications

Avant toute chose, faisons une petite analogie pour (justement) comprendre le fonctionnement analogique de notre modèle.

il faut se représenter cela comme un aiguille parcourant un compteur de vitesse de voiture. On part de la valeur la plus basse (0 km/h) pour atteindre une valeur de destination en fonction de l’appui sur l’accélérateur puis une descente de ce compteur lorsque l’on relâche. Pour rouler en ville, on peut aller jusqu’à 50 km/h puis lors de la sortie de l’agglomération, on appui sur l’accélérateur pour passer à 80 km/h puis on arrive chez soi et on arrête la voiture (0 km/h). Le fait de passer de 80 km/h à 0 km/h implique que l’on soit passé par la vitesse de 50 km/h lors de la décélération. Même si cela n’a pas d’importance au volant d’une voiture, c’est une propriété qu’il faut prendre en compte dans notre cas.

Ici nous avons le même principe : chaque valeur analogique de notre tableau implique que nous pouvons passer par plusieurs seuils pré-définis avant d’atteindre le seuil désiré. Par exemple , la valeur analogique de détection de courrier étant de 2700, nous sommes donc passé par le seuil d’ouverture de porte (500), celle du clapet (1170), celle de l’ouverture du clapet et de la porte simultanée (1790) pour enfin atteindre celle de la détection de présence de courrier (2700).

Problème : le facteur a déposé le courrier via le clapet et uniquement celui-ci, or comment savoir que seul le clapet a été utilisé sachant que les autres seuils (porte, porte + clapet) ont été franchis : c’est ce que nous avons géré via les scénarios ci-dessus et dont voici le détail.

D’abord on défini les seuils analogiques de chaque état (ouverture porte, ouverture clapet, présence courrier, ouverture porte avec courrier, ouverture clapet avec courrier) selon les valeurs du tableau de correspondance, en prenant une marge de sécurité dû à la variation du courant qui peut différer par rapport à notre relève initiale. On ne prend pas en compte l’ouverture clapet + porte simultané car ne présente pas d’intérêt dans notre cas (scenario 0-1-2-3). Chacun de ces scenarios défini également un compteur temporaire à une valeur de 1 propre au seuil analogique franchi.

Note : Le seuil bas des entrées analogiques définissent le seuil minimum en dessous duquel l’entrée se désactivera (OFF), le seuil haut quant à lui défini le seuil minimum au dessus duquel l’entrée analogique s’activera (ON) : entre les 2 c’est l’hystérésis. Elle n’est pas prise en compte par nos scénarios quand cette dernière est de vigueur car ce qui nous intéresse ici c’est le simple franchissement d’un seuil afin d’activer ou non la sortie virtuelle associée. C’est pourquoi le seuil bas et le seuil haut auront la même valeur : en dessous de cette valeur on considérera cela inactif, au dessus cela sera considéré comme actif.

Comme mentionné à l’instant, chacun de ces états passent leur sortie virtuelle associée à ON une fois le seuil franchi et OFF une fois en dessous, sauf pour la présence de courrier que l’on passe à ON uniquement une fois le seuil franchi, on ne tient pas compte du refranchissement retour (scenario 4). Pour cela, on met en place un autre scenario afin de définir quand à lieu la relève du courrier en définissant une valeur analogique en dessous des valeurs de seuils possibles (ex :400) (scenario 5). Si cela n’était pas fait, la descente du seuil analogique à 0 déclencherai les ouvertures porte et clapet sans courrier lors du retour (voir ci-après).

En cas d’ouverture du clapet, on passe la sortie virtuelle d’ouverture de la porte à OFF car ce dernier aura été déclenché à ON précédemment (par le scénario 0) étant donné que le seuil analogique de la porte (500) se situe en dessous du seuil analogique du clapet (1170). Le fait donc de passer de 0 à 1000 (seuil d’ouverture clapet avec la marge de sécurité) active cette sortie alors que l’on veut préciser que seul le clapet a été ouvert. Pour palier à cela, on réinitialise le compteur temporaire de la porte à 0 (scenario 6) et on passe la sortie virtuelle de la porte à OFF (scenario 7).

Les scénario 8 quant à lui est un peu plus particulier : lorsque les seuils du clapet OU de la porte sont franchis, nous souhaitons activer une sortie virtuelle (BAL_Tempo) qui possède une temporisation d’une seconde : cela veut dire qu’au bout d’une seconde, cette entrée virtuelle repasse automatiquement à l’état OFF après avoir été activée. Elle sera utile dans la suite des scénarios ci-dessous, nous la plaçons ici car comme spécifié plus haut, l’ordre des scénarios à son importance dans l’exécution séquentielle de ces derniers.

Si un courrier est présent et que la porte et le clapet n’ont pas été ouverts (en cas de redémarrage de l’IPX ou du module Arduino), il faut également spécifier la même chose que précédent, passer la sortie virtuelle du clapet et porte à OFF et détection de courrier à ON (scenario 9).

Vous vous souvenez de la sortie virtuelle BAL_Tempo et de sa temporisation que l’on a mis en place précédemment ? Et bien nous allons l’utiliser ici (scénario 10 & 11). Dans ces 2 scénarios, nous allons commencer par contrôler que cette sortie virtuelle est bien sur 0, dans le cas contraire le scénario ne sera ignoré et ne sera donc pas exécuté : et ceci à son importance. En effet, il faut en général moins d’une seconde pour que la valeur analogique ciblée atteigne son seuil, et donc que toutes les valeurs précédemment définies par les scénarios en amont soient dans un état stable après cette temporisation (définitions des sorties virtuelles, des compteurs, etc…). On part donc du principe qu’au bout de cette seconde après le déclenchement d’un des scénario précédent nous pouvons agir pour définir d’autres règles comme le fait d’incrémenter le compteur du clapet ou de la porte de 1, voulant dire alors que c’est bien ce dernier dispositif qui a été utilisé pour la dépose du courrier et également de passer son statut (BAL_Statut_Porte ou BAL_Statut_Clapet) à ON ou OFF en fonction de la sortie virtuelle de son dernier état (BAL_Porte_Tempo ou BAL_Clapet_Tempo).

Nous arrivons ensuite dans les derniers scénarios de cette gestion de boite à lettres (scénarios 12-13-14) . Comme spécifié plus haut, l’ordre des scénarios à une importance dans leur exécution (séquentielle) et on peut considéré que lorsque l’IPX arrive à ces scénarios, chaque sorties virtuelles, compteurs ou autre (ex : push) ont déjà été définis et que les actions à mener ont été réalisées, il est donc temps de réinitialiser les différents compteurs/sorties pour la prochaine exécution du processus.

Interface

Grâce aux différents compteurs et sorties virtuelles mis à disposition à travers nos scénarios, nous pouvons désormais mettre en place un petit widget sympathique sur la dashboard d’accueil de notre IPX afin de suivre l’évolution de la vie de notre boîte à lettres ;-).

Conclusion

Je suis parti sur une double détection (ouverture clapet/porte + détection de courrier), cependant il est tout à fait possible de moduler ce projet afin de le simplifier pour ne garder que la détection de courrier par exemple.

La multiplicité des scénarios sur l’IPX pourra paraître assez complexe à appréhender car le fonctionnement de ces derniers est assez limité (par exemple l’impossibilité d’utiliser plus d’une entrée analogique dans les évènements) cependant avec un peu de réflexion nous arrivons à quelque chose qui à le mérite d’être fonctionnel à 100%, et c’est le principal.

Il s’agit de mon premier projet à base d’Arduino (et sûrement pas le dernier) et je dois avouer que cet univers est vraiment passionnant, qui demande certes un peu d’investissement au départ afin de le comprendre et l’exploiter au mieux (électronique, programmation en C/C++, etc…) mais qui au final donne une certaine satisfaction une fois le projet abouti.

J’en profite également pour remercier chaque contributeur m’ayant aidé dans l’aboutissement de mon projet : mon entourage, la communauté du forum de GCE, des projets similaires comme celui cité en introduction de cet article, et bien d’autres… Le partage est une force et c’est encore une fois démontré ici.