Parce qu’une télécommande c’est surfait, place au cadre-télécommande !

Pour contrôler mes prises et interrupteurs radio commandés, j’utilise homebridge et un arduino nano controlé par une application node depuis un raspberry pi. Seulement, je n’ai rien pour allumer les lumières lorsque je n’ai pas mon téléphone à portée de main, je suis alors obligé de me déplacer (pff) et c’est un grave problème. Pour y remédier, j’avais utilisé dans un premier temps une tablette android démontée dans laquelle j’avais glissé un morceau de miroir sans tain, en glissant le tout dans un cadre fait maison. Cela n’était pas sans rappeler le miroir intelligent qui trône fièrement dans ma salle à manger ! Le résultat n’était pas mal, mais je dépendais trop de la stabilité de mon installation homebridge sur laquelle j’expérimentait. Du coup j’ai eu l’idée de faire un nouveau cadre télécommande, qui consisterais en une série de boutons qui enverraient des signaux radio. Il fallait juste trouver comment le faire de façon originale !

 

Première idée abandonnée

Cette idée à base de tablette android aura tout de même fonctionné plusieurs mois… et je ne résiste pas à la tentation de laisser ici le processus de montage pour la postérité. Je vous épargne le code, il s’agit d’une simple page HTML avec des boutons qui envoient une requête POST :

Malheureusement, si ce projet à orné le mur de mon entrée pendant 6 mois, j’ai également beaucoup expérimenté pendant ce temps un boitier de domotique fait maison avec un raspberry pi et homebridge. Ce qui fait qu’il se passait parfois quelques jours pendant lesquels le miroir/télécommande était inutile. J’ai donc opté pour une solution « standalone » avec un cadre derrière lequel j’irais loger des boutons ainsi qu’un micro contrôleur qui commande un émetteur radio.

Rassemblons les morceaux

Pour ce projet vous aurez besoin de matériaux que vous devriez avoir dans votre tiroir. Si vous ne les avez pas déjà, achetez les, ça sert toujours :

  • Un fer à souder et du fil, car l’Arduino vient avec ses headers non soudé.
  • Quelques câbles jumper mâle-femelle.
  • Du fil. beaucoup de fil 🙂
  • Des headers à assembler (La boite de 310 pièces coûte 5$ chez banggood).
  • Un cadre quelconque, j’ai acheté le mien 1,25$ dans un magasin de trucs et bidules.
  • Une prise femelle micro USB ou une quelconque source d’alimentation permettant d’amener du 5V.
  • Facultatif : Une led (j’ai récupéré une vieille SMD5050 d’un ancien projet)

Vous n’aurez en outre besoin d’aucun composant ésotérique :

  • Un Arduino Nano : 4$ chez banggood (armez-vous de patience pour la livraison).
  • Un émetteur radio 433MHz : 5$ sur amazon.
  • Une dizaine de boutons capacitif de type TTP223 (3,50$ les 10 chez banggood).

 

Préliminaire : l’alimentation

Il s’agira ici surtout d’un conseil : Tous les composants ou presque devront être alimentés en permanence. Cela pourrait essouffler notre arduino, et on veut alors chercher une éventuelle source alternative d’alimentation que le pin +5V de l’arduino. Je ne me base que sur mon intuition pour cela, mais comme cela ne me demande pas d’effort particulier pour concevoir mon circuit ainsi, autant épargner le nano, non ?

J’ai donc choisi de faire arriver le courant par une prise femelle micro USB récupérée sur une de ces bricoles qui ne marchent plus mais que je ne jette jamais au cas où. Je les démonte et en récupère certains composants :

Il m’a suffit d’un test rapide avec un voltmètre pour identifier sur le morceau de circuit imprimé le GND et le +5V. De là j’ai soudé mes fils dessus et les ai prolongés le long du cadre, en y greffant ci et là les raccords nécessaires.

 

Design et schéma de montage

Voici les raccords que je souhaitais faire :

  • USB/GND sur Arduino/GND
  • USB/5V sur Arduino Vin
  • TTP223/IO sur Arduino D2 à 11
  • RF433/Data sur Arduino/A7
  • LED+Resistance sur Arduino/A0
  • Puis les Vin des composants sur le USB/5V
  • Et les GND des composants sur le USB/GND

Et donc en plus clair ce que j’ai imaginé : D’abord le design, puis les composants qui devront se loger derrière.

 

Rien de permanent !

J’aime bien pouvoir réutiliser les bricolages dont je me suis lassé. Qui plus est, on est jamais à l’abris d’un composant défectueux, qui grille… Ou tout simplement que je veuille revoir la disposition des boutons. C’est pour cette raison que je me suis lancé comme défis de rendre tous les composants et dans la mesure du possible toutes les connections amovibles.

Une autre raison à cela : Comme je souhaite alimenter l’arduino par les pins GND et Vin, je ne voudrais pas prendre de risque lorsque je le branche sur l’ordinateur pour la programmation. J’ai donc fait en sorte de pouvoir débrancher tout ce va dans ou depuis l’arduino. Idem pour les TTP223. Et bien m’en a pris, je me suis rendu compte à la fin que j’en avait un défectueux, donc facile à remplacer dans ma configuration.

Le montage des headers est assez simple. Voici une très bonne vidéo sur comment monter des jumpers cables. Ne prêtez pas attention à l’outil utilisé, une simple pince à parfaitement fait l’affaire pour moi !

 

Montage de test sur une feuille de papier

J’ai imprimé le design en mode miroir sur une feuille A4 pour tester la pertinence de l’organisation des fils telle que je l’avais conçue. Les résultats étaient encourageants !

 

Et si on parlait du code ?

Je vais considérer que vous avez déjà lu les codes de vos télécommandes pour cette partie (voir l’article à ce sujet). Nous avons donc quelque chose de particulier qui va lire l’activation du touch sensor… Voici le code d’exemple qu’on trouve partout sur internet :

 

/*
Author: Danny van den Brande. Arduinosensors.nl. BlueCore Tech.
Hello world! Today i made a code for the TTP233B capacitive touch sensor.
Its very simple and you can toggle on and off a led/relay or whatever you wanna add.
 */
#define TouchSensor 9 // Pin for capactitive touch sensor
int relay = 2;
boolean currentState = LOW;
boolean lastState = LOW;
boolean RelayState = LOW;
void setup() {
  Serial.begin(9600);
  pinMode(relay, OUTPUT);
  pinMode(TouchSensor, INPUT);
}
void loop() {
  currentState = digitalRead(TouchSensor);
    if (currentState == HIGH && lastState == LOW){
    Serial.println("pressed");
    delay(1);
    if (RelayState == HIGH){
      digitalWrite(relay, LOW);
      RelayState = LOW;
    } else {
      digitalWrite(relay, HIGH);
      RelayState = HIGH;
    }
  }
  lastState = currentState;
}

 

Dans l’idée, le TTP223 va envoyer un signal HIGH lorsqu’il est touché, et LOW s’il est laissé tranquille. Donc ce qu’on va faire c’est tester nos capteurs un par un jusqu’à en trouver un qui est touché, et effectuer une action spécifique en conséquence. Dans notre cas, émettre un signal radio particulier.

Voici le code que j’ai utilisé, certainement perfectible (je vous encourage à me corriger d’ailleurs si vous voyez des énormités, je ne demande que ça!) :

#include <RCSwitch.h>
#define SalonPlafondON    11
#define SalonPlafondOFF   10
#define SalonLampeOFF     9
#define SalonLampeON      8
#define SamPlafondON      5
#define SamPlafondOFF     4
#define SamLampeOFF       3
#define SamLampeON        2
#define CuisineMeubleON   7
#define CuisineMeubleOFF  6
#define TouchLed A7 // Pin for led
#define RFsender A0 // Pin for RF
RCSwitch mySwitch = RCSwitch();
int val = 0;
bool SPON;    bool SPOFF;
bool SLON;    bool SLOFF;
bool SAMPON;  bool SAMPOFF;
bool SAMLON;  bool SAMLOFF;
bool CMON;    bool CMOFF;
void setup() {
  Serial.begin(9600);
  pinMode(TouchLed, OUTPUT);
  pinMode(SalonPlafondON, INPUT);
  pinMode(SalonPlafondOFF, INPUT);
  pinMode(SalonLampeOFF, INPUT);
  pinMode(SalonLampeON, INPUT);
  pinMode(SamPlafondON, INPUT);
  pinMode(SamPlafondOFF, INPUT);
  pinMode(SamLampeOFF, INPUT);
  pinMode(SamLampeON, INPUT);
  pinMode(CuisineMeubleON, INPUT);
  pinMode(CuisineMeubleOFF, INPUT);
  digitalWrite(TouchLed, LOW);
  mySwitch.enableTransmit(RFsender);
  mySwitch.setPulseLength(185);
  mySwitch.setRepeatTransmit(8);
}
void loop() {
  SPON   = digitalRead(SalonPlafondON);  SPOFF    = digitalRead(SalonPlafondOFF);
  SLON   = digitalRead(SalonLampeON);    SLOFF    = digitalRead(SalonLampeOFF);
  SAMPON = digitalRead(SamPlafondON);    SAMPOFF  = digitalRead(SamPlafondOFF);
  SAMLON = digitalRead(SamLampeON);      SAMLOFF  = digitalRead(SamLampeOFF);
  CMON   = digitalRead(CuisineMeubleON); CMOFF    = digitalRead(CuisineMeubleOFF);
  if ( SPON || SPOFF || SLON || SLOFF || SAMPON || SAMPOFF || SAMLON || SAMLOFF || CMON || CMOFF ){
      //SALON PLAFOND ON
      if ( SPON && !(SPOFF || SLON || SLOFF || SAMPON || SAMPOFF || SAMLON || SAMLOFF || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //SALON PLAFOND OFF
      else if ( SPOFF && !(SPON || SLON || SLOFF || SAMPON || SAMPOFF || SAMLON || SAMLOFF || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //SALON LAMPE ON
      else if ( SLON && !(SPOFF || SPON || SLOFF || SAMPON || SAMPOFF || SAMLON || SAMLOFF || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //SALON LAMPE OFF
      else if ( SLOFF && !(SPOFF || SLON || SPON || SAMPON || SAMPOFF || SAMLON || SAMLOFF || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //SAM PLAFOND ON
      else if ( SAMPON && !(SPOFF || SLON || SLOFF || SPON || SAMPOFF || SAMLON || SAMLOFF || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //SAM PLAFOND OFF
      else if ( SAMPOFF && !(SPOFF || SLON || SLOFF || SAMPON || SPON || SAMLON || SAMLOFF || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //SAM LAMPE ON
      else if ( SAMLON && !(SPOFF || SLON || SLOFF || SAMPON || SAMPOFF || SPON || SAMLOFF || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //SAM LAMPE OFF
      else if ( SAMLOFF && !(SPOFF || SLON || SLOFF || SAMPON || SAMPOFF || SAMLON || SPON || CMON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //CUISINE MEUBLE ON
      else if ( CMON && !(SPOFF || SLON || SLOFF || SAMPON || SAMPOFF || SAMLON || SAMLOFF || SPON || CMOFF ))  {
        mySwitch.send("XXX");
      }
      //CUISINE MEUBLE OFF
      else if ( CMOFF && !(SPOFF || SLON || SLOFF || SAMPON || SAMPOFF || SAMLON || SAMLOFF || CMON || SPON ))  {
        mySwitch.send("XXX");
      }
      digitalWrite(TouchLed, HIGH);
  }
  else{
      digitalWrite(TouchLed, LOW);
  }
  delay(50); //Pour se laisser un peu de temps
}

 

Après des heures de tentative de débuggage à cause de TTP223 qui semblaient se déclencher tous seuls, j’ai choisi de considérer systématiquement l’unicité d’une activation avant d’en acter la validité. D’où les tests à rallonge 🙂

Bref, j’ai également ajouté du scotch tape d’électricien pour isoler la lumière des touche sensors et de l’arduino, afin que seule la lumière de la LED du haut ne soit perceptible à travers le cadre en plastique, lorsqu’une pression était détectée.

Quelques tests plus tard j’étais prêt pour le montage final !

 

 

Conclusion et améliorations

J’ai un regret que je vais combler dans quelques temps, c’est de ne pas avoir assez exploité le deep sleep de l’arduino. C’était une occasion parfaite pour cela, mais ça sera pour un prochain projet. Pour l’heure, je me contente d’apprécier ma nouvelle télécommande 🙂

 

Laisser un commentaire

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