Shield maison pour programmateur universel

Objectifs

Au détour d’une conversation, mon frère m’a dit qu’une chose l’ennuyait avec sa machine à laver: c’est un modèle qui ne permet pas de départ différé. L’utilisation d’un programmateur se branchant sur la prise électrique ne permet pas de résoudre se problème, car il faut appuyer sur un bouton pour lancer le cycle de lavage. Je lui ai donc proposé de réaliser un programmateur résolvant son problème.

Les contraintes sont un peu différentes du programmateur pour four que j’ai réalisé. D’abord, il faut modifier au minimum la machine à laver (soudure, perçage …). Cela signifie qu’il faut une alimentation et un boitier externe. Ça a l’avantage de laisser toute la liberté pour la conception de l’interface ! D’autre part, contrairement au four, la fonctionnalité est très simple: pas de sonnerie, pas besoin de multiples programmes … et je me suis fixé comme objectif de pousser au maximum cette simplicité et de conserver des coûts modestes. Pas d’afficheur LCD 4×20 cette fois (et encore moins graphique) mais un simple afficheur 4×7 segments suffira. Pas besoin non plus de conserver l’heure et la date, donc pas de DS 1307.

J’ai décidé de m’orienter vers une interface  simple et intuitive en utilisant un encodeur rotatif avec bouton poussoir. Un seul bouton servira donc à régler le délai de déclenchement (en tournant) et à lancer le compte à rebours (en appuyant). L’afficheur doit non seulement afficher le décompte mais aussi permettre de visualiser si le compte à rebours est en cours où non. Le séparateur décimal (le . servant de virgule au pied de chaque chiffre) permettra d’afficher un point défilant lorsque le décompte est en cours. De plus, tourner le bouton sera sans effet durant le décompte. Appuyer dessus permet de mettre en pause le décompte et d’ajuster à nouveau le délai. Afin que le réglage se fasse plus rapidement, et parce qu’une précision supérieure est inutile, le pas sera de 15 minutes.

Réalisation du circuit

Afficheur

L’afficheur est un YSD-439AB4B-35 (datasheet). Le circuit fournit dans le datasheet permet de comprendre comment il fonctionne: ce n’est en fait qu’un ensemble de 35 leds câblées de manière intelligente afin de pouvoir être contrôlées simplement. 4 pins permettent de sélectionner le chiffre que l’on désire contrôler en la passant à l’état bas (0V). 8 pins permettent de sélectionner les segments à allumer (ce sont les mêmes 8 pins pour les 4 chiffres: 7 segments pour le chiffre et un pour un point (.) en bas à droite du chiffre). Pour afficher plusieurs chiffres en même temps, l’astuce consiste à faire clignoter les LED rapidement, chacune à son tour, en sélectionnant à chaque fois les segments à allumer pour afficher le chiffre désiré. Les 3 LEDs et 4 broches restante servent à allumer les deux points (:) au milieu des 4 chiffres et un point supérieur placé en haut du 3è chiffre.

En théorie, l’afficheur ne devrait pas être soumis à une tension supérieure à 3.5V. De plus, chaque LED peut nécessiter un courant de 20mA en moyenne et de 30mA en pic. Il serait donc préférable d’utiliser des résistances pour limiter le courant.

Cependant, si l’on regarde le datasheet de l’ATMega 328P (le micro-contrôleur de l’arduino), on peut trouver le diagramme suivant:

ATMega328P_ioVCC5V

Ce diagramme signifie que pour une tension aux bornes de la LED de 3.5V, le courant que fournira l’arduino sera d’environ 40mA, courant qu’il peut supporter. Ce courant est normalement un peu élevé pour la LED mais ne sera fournit que pendant un laps de temps très court. En théorie, on reste au delà des limites. En pratique, cela ne pose pas de problème, probablement grâce à la marge de sécurité prise aussi bien côté ATMega que côté afficheur. Bien sûr, il vaut mieux éviter ce genre de raisonnement sur un circuit critique !

Reste du circuit

L’opto-coupleur est un classique 4N35 (datasheet). La seule chose importante est de ne pas oublier que c’est un ensemble LED + photo-transistor et que donc, contrairement à un interrupteur, la polarité est importante. Si il est branché « à l’envers » sur le bouton que l’on veut lui faire commander, ça ne fonctionnera pas !

L’encodeur rotatif est un EC12E1564402 (datasheet). Ici encore, il n’y a qu’un point important et non trivial à savoir, qui se trouve dans le datasheet mais que l’on peut facilement manquer. Dans l’image qui suit, les lignes pointillées symbolisent les positions « stables » de l’encodeur. Cela signifie que tout ce qui se trouve entre est transitoire.

outputwave

Dans mon code initial, je n’avais pas pris cela en compte et le résultat était que je ne parvenais pas à incrémenter la durée de seulement 15 minutes. A chaque fois, l’augmentation se faisait par pas de 30 minutes, même si je pouvais observer la valeur intermédiaire correspondant à 15 minutes s’afficher brièvement.

Montage

La réalisation du circuit sur une plaquette de prototypage ne pose pas de difficulté particulière. On veillera simplement à faire attention au câblage de l’afficheur. Le datasheet ne contient pas de schema de numérotation des pins mais celui-ci est standard, le numéro 1 étant en bas à gauche, le 8 en bas à droite, le 9 en haut à droite et le 16 en haut à gauche. Une erreur de câblage n’aurait rien de catastrophique mais résulterait simplement en un affichage complètement incohérent.

Programmation

Le croquis est composé de deux fichiers:

– Un fichier d’en-tête types.h qui ne fait que définir deux enums

– Le fichier Programmateur.ino qui contient le code en lui même.

Utiliser plusieurs fichiers pour un croquis dans l’IDE arduino est très simple. Pour ajouter un nouveau fichier, il suffit de cliquer sur la flèche vers le bas située tout à gauche dans le bandeau d’onglets et de cliquer sur nouvel onglet (ou d’utiliser le raccourci clavier Ctrl+Shift+n) et de fournir le nom du nouveau fichier.

Le code est relativement simple et bien commenté. Les points méritant d’être mentionnés sont:

Le défilement des points

Il est basé sur la ligne suivante:

 if(currentMode == COUNT && (beginTime/250)%4 == (digit-1))

Cette ligne est dans la boucle se chargeant de l’affichage de chaque chiffre dans laquelle la valeur de digit varie de 4 à 1. La première partie de la clause ET vérifie si l’on est dans le mode COUNT (décompte du temps) l’alternative étant le mode SETUP (permettant le réglage de la durée). C’est logique puisque le défilement des points sert justement à informer l’utilisateur que le décompte est en cours (le temps affiché étant HH:MM, il ne bouge pas souvent, il faut donc un autre retour visuel pour confirmer).

La seconde partie de la clause ET permet de choisir quel point allumer. La variable beginTime contient la valeur retournée par la fonction millis() au début de la fonction, avant d’entrer dans la boucle. le fait de la diviser par 250 permet donc d’avoir la valeur « relative » du quart de seconde courant. « Relative » car on ne sait pas vraiment à quand correspond la valeur 0 (soit le démarrage de l’arduino, soit la dernière fois que le compteur retourné par millis a bouclé), mais ça n’a au final pas d’importance. On prend ensuite le reste par la division par 4 de ce nombre de quart de seconde. On n’allumera le point d’un chiffre que si ce reste est égal à l’indice de ce chiffre.

Ainsi:

millis() 1/4 de seconde chiffre
0-249 0 0 (tout à gauche)
250-499 1 1
500-749 2 2
750-999 3 3
1000-1249 4 0
1250-1499 5 1
1500-1749 6 2
1750-1999 7 3
2000-2249 8 0
etc…

La gestion du temps

Le temps à attendre en minutes est stocké dans la variable duration. En mode SETUP, cette variable est modifiée par la fonction readDuration() en fonction de ce que fournit l’encodeur rotatif.

Lorsque l’on passe en mode COUNT, dans la fonction handleButton(), la variable end_millis est calculée en ajoutant duration*SECONDS_IN_MINUTE*1000 à millis(). Le programmateur déclenchera la machine à laver lorsque millis() atteindra end_millis. La variable duration est maintenue à jour en permanence dans updateDuration() en faisant l’opération inverse: (end_millis – millis()) / SECONDS_IN_MINUTE / 1000.

Ce design un peu particulier vient du développement incrémental, partant de l’afficheur et de tests permettant d’afficher une valeur en minutes. Une des conséquences est que si l’on passe du mode SETUP au mode COUNT puis de nouveau au mode SETUP rapidement (c’est à dire si on appuie 2 fois sur l’encodeur rotatif), le temps est décrémenté d’une minute. Cette fonctionnalité non désirée m’a plu, fournissant un moyen simple et pratique de régler plus précisément le minuteur (même si ça ne présente qu’un intérêt limité). J’ai donc conservé ce design.

Réalisation du shield

Pour me simplifier la vie, j’ai décidé de conserver l’arduino dans le montage final plutôt que de faire un montage ne contenant qu’un ATMega. Cela évite d’avoir à ajouter un régulateur de courant, un connecteur pour l’alimentation etc … et permet de facilement reprogrammer le microcontrôleur en cas de besoin.

Pour obtenir un circuit compact et robuste, j’ai donc voulu faire un shield sur une plaque à bandes perforées. Je me suis cependant heurté à un problème: deux des broches de connecteurs de l’arduino ne sont pas espacées du pas normal de 2.54mm mais de la moitié de cette valeur. C’est semble-t-il une erreur introduite tout à la fin de la conception de l’arduino et plusieurs solutions existent pour réaliser des shields malgré ce problème. Ce site décrit le problème en détail:

http://electroniqueamateur.blogspot.fr/2011/09/fabrication-de-shields-arduino-sur-une.html?m=1

J’ai pour ma part opté pour la solution « tordre les pins », et cela fonctionne à merveille. Comme on peut le voir sur les photos, la torsion nécessaire est très légère.

circuit1

 

circuit3

circuit2

Conception du boitier

Dans la mesure où il était prévu de garder le circuit externe à la machine, j’ai réalisé un boitier en impression 3D à l’aide d’OpenSCAD. Les mesures ont été prises un peu rapidement à l’aide d’un double décimètre (je n’ai pas encore de pied à coulisse), j’ai donc du prévoir de la marge dans les ouvertures. Et bien au final, cela ne rend pas trop mal !

Capture du 2015-11-16 18-04-09
Capture du 2015-11-16 18-02-37

J’ai également voulu expérimenter deux choses. D’une part j’ai disposé des plots au fond de la boite à la position des trous de vis de l’arduino, l’objectif étant de le caler. Malheureusement, malgré le jeu prévu, les plots ont un diamètre plus large une fois imprimés que dans le modèle et ne rentrent pas dans les trous. Ce n’est pas la première fois que je constate une tendance du plastique à s’étendre « vers l’extérieur » lors de l’impression (les trous sont plus petits que prévus, les pleins sont plus grands que prévus). Au final, ce n’est pas très gênant car une fois le couvercle mis, le tout est bien calé.

D’autre part, j’ai voulu faire un système permettant au couvercle d’être maintenu en faisant deux taquets dans le couvercle censés venir se loger dans deux trous dans le boitier. Seulement le résultat n’est pas du tout flexible et ne fonctionne donc pas. J’ai du les casser pour pouvoir rentrer le couvercle.

Ce boitier devait être un prototype et a été imprimé à vitesse élevée car j’étais certain qu’il faudrait retoucher certaines choses, d’où le gros grain et les défauts d’impression visibles dans les photos. Au final, tous les trous étaient à leur place, le circuit rentrait bien et le tout (circuit, couvercle et alim) rentrait légèrement en force ce qui permettait de tenir en place sans vis ni colle, malgré la suppression des taquets ! Je n’ai donc pas imprimé de seconde version avec une meilleure finition.

boitier
boitier2

 

Installation

Dans un projet, il y a souvent des imprévus. C’est toujours embêtant lorsque l’on n’a pas prévu quelque chose de nécessaire et qu’on est bloqué pour ça. Dans notre cas, ce fut l’inverse ! Le boitier externe s’est révélé une précaution inutile, l’insertion du montage dans la machine s’étant révélé facile sans trop l’abîmer.

IMG_1627

final

Cette entrée a été publiée dans Electronique, Projets. Vous pouvez la mettre en favoris avec ce permalien.

2 réponses à Shield maison pour programmateur universel

  1. Jean Michel dit :

    Bonjour
    J’ai trouve votre article tres interessant, mais pourquoi ne pas avoir ete plus loin en refaisant avec un arduino le programmateur complet, une machine a laver n’etant pas tres complexe.
    Merci quand meme pour votre article, je m’en inspirerai pour faire un programmateur universel pour machine a laver.
    Jean Michel

    • Colin Pitrat dit :

      Bonjour,

      j’avais déjà fait le programmateur pour four qui était plus complexe (http://colin.pitrat.free.fr/?p=16). Je voulais essayer quelque chose de plus simple avec une interface minimaliste et qui soit réutilisable tel quel.

      De plus, le besoin était simple. J’ai préféré me concentrer sur une interface vraiment agréable à utiliser et qui fait le travail. On ne le voit pas ici, mais l’encodeur rotatif est vraiment agréable à utiliser.

      Et puis, même avec une interface simple, on peut tout de même cumuler (et peaufiner) quelques fonctionnalités. Le défilement des points fait que l’on voit clairement si le décompte est en cours ou si l’on est en mode réglage. Il y a aussi la veille, qui évite que l’afficheur soit allumé en permanence (il allume vraiment fort lorsqu’il est au maximum). Enfin, la résolution du réglage en tournant l’encodeur est de 15 minutes mais si l’on veut être vraiment précis, deux appuis successifs sur l’encodeur permettent de décrémenter d’une minute.

      Colin

Répondre à Jean Michel Annuler la réponse.

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

+ un = dix

Vous pouvez utiliser ces balises et attributs HTML : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>