- Régulateur de niveau -
Projet:
Réaliser l'électronique de commande pour une pompe destinée
à alimenter le réservoir d'eau d'une fontaine décorative.
1- Le niveau doit être maintenu entre niveau haut et bas dans le réservoir. La pompe
ayant un débit bien supérieur à celui de la fontaine, elle ne tourne que par
moment.
2- Une sécurité bloque le cycle de remplissage si la pompe tourne pendant un
temps trop long (crépine bouchée, plus d'eau, etc.).
Après avoir réalisé un montage nécessitant deux quadruples "NAND " et davantage de composants, on se propose de remplir ce même cahier des charges avec un seul microcontrôleur "ATtiny85" (très bon marché et avec très peu de composants annexes).
Matériel:
- Pour programmer l'ATTiny85 (autour de 1 € !), il faut cependant disposer d'une platine "Arduino Uno R3" (dix ou vingt Euros) et d'un ordinateur.
- Une alimentation régulée de 5v ou a défaut de 9 ou 12V
continus suivie d'un circuit régulateur 5V LM7805 avec deux condensateurs:
- Une platine relai 5V pour commander 220V/10A type:
- Platine support, barrette dominos, condensateurs, quelques résistances, une
LED rouge, un boitier.
Réalisation en 3 temps:
I/ Programmation avec l’ordinateur et l’Arduino et tests
du programme (donné en annexe):
L’IDE (Programme d’interface avec l’Arduino pour l’ordinateur) est
téléchargeable ici: https://www.arduino.cc/en/Main/Software
- Ouvrir dans l’IDE le programme pour l’ATtiny (écrit
en "C") (en fin d’Annexes ci-dessous), adapter la valeur de maxTime
et vérifier le tout avec le bouton "V" de l'IDE.
NB 1: Pour les tests c'est l'Arduino qui joue provisoirement le rôle de
l'ATtiny et fait tourner son programme.
La constante "sortiePin" est donc mise à 13 au lieu de 4 pour que la
diode LED jaune intégrée à l'Arduino simule visuellement le déclenchement futur
du relai.
NB 2: La platine relai qui sera utilisée ici contacte la pompe pour une entrée
à "0", la LED sera donc allumée au repos...
(Pour une platine différente, inverser simplement HIGH et LOW en fin de
programme).
NB 3: La constante "maxTime" de déclanchement de la sécurité
doit être ajustée en fonction du temps de remplissage maximum du réservoir...
(Mais attention! L'ATtiny85 n'aura pas forcément le même "maxTime"
pour un délai souhaité équivalent, car fonction de sa fréquence
d'horloge. Mais au final l'essai in situ suivi d'une "règle de trois"
permettra son ajustement éventuel après reprogrammation de l'ATtiny... ).
- Puis, transférer (téléverser) le programme ajusté de l’IDE dans l'Arduino
(bouton "flèche droite" de l'IDE) pour les essais.
NB: Pour pouvoir transférer un programme, il faut (dans le menu
"Outils"), que le bon port COM soit sélectionné ainsi que la carte
"Arduino/Genuino Uno".
II/ Programmation de l'ATtiny85:
L’Arduino doit être transformé en programmateur pour
transférer dans l’ATtiny le mini programme qui lui a été téléversé ci-dessus.
Pour cela, il faut l’interconnecter avec l’Arduino en fils volants ou mieux,
réaliser une petite platine de programmation pour l'ATtiny qui s'enfichera sur
l'Arduino (La LED et la 1 KOhms sont tout à fait facultatives):
Pour la marche à suivre logicielle, lire l'annexe ci-après.
III/ Montage final:
Monter une platine pour l'ATtiny, le relai et
l'alimentation, dans un boitier, (LED visible):
NB 1: La LED allumée indique qu'il y a eu disjonction par la
sécurité.
NB 2: Les sondes (haute et basse) peuvent être interverties sans conséquence...
ANNEXES:
Dans le logiciel IDE Arduino:
Pour faire tourner un simple programme:
======================================
Vérifier auparavant le programme avec le bouton "V".
Puis le transférer (« téléverser »)(bouton "flèche droite").
NB: Pour pouvoir correctement téléverser un programme, il faut (dans "Outils") que le bon port COM soit sélectionné ainsi que la carte "Arduino/Genuino Uno".
Pour programmer (ou reprogrammer) un ATTINY85:
==============================================
Il faut d'abord posséder les bons outils logiciels en remplissant
dans Fichier/Préférences/Paramètres:
Puis dans Outils/Type de cartes/Gestionnaire de cartes, (filtrer « attiny »). Se positionner sur : « attiny by Davis A. Mellis », "Installer" apparaît : Installer.
Dans Outils/Type de carte, il doit désormais y avoir "Attiny".
Lancer l'IDE Arduino et charger le script ArduinoISP (disponible via le menu dans Fichier/exemples, pour rendre l’Arduino programmateur).
Outils/Type de carte : « Arduino/Genuino UNO ».
Outils/Programmateur : « Arduino as ISP ».
Choisir le bon port COM.
Transférer le programme.
Si le transfert s’effectue correctement, les diodes doivent clignoter.
L'Arduino est prêt à programmer des Attiny!
Débrancher éventuellement l’Arduino de l’ordinateur (USB).
Connecter l’ATtiny correctement, (fils volants ou carte bien orientée avec son condensateur de 10µF 25V côté opposé USB).
NB: Le condensateur empêche la carte Arduino de faire un reset et de redémarrer le bootloader
lors des téléversements destinés à l’Attiny.
Rebrancher l’Arduino à l’ordinateur.
Ouvrir le programme à envoyer à l’ATtiny (ci-dessous) et configurer l’IDE Arduino:
Dans «Outils» sélectionner :
Le bon port COM
Outils/Type de carte : Attiny,
Outils/Processeur : Attiny85,
Outils/Clock « Internal 1 MHz »
Outils/Programmateur : Arduino as ISP.
Téléverser.
LE PROGRAMME pour l'ATtiny:
==========================
//-----------------------------------------------------------------
// JPB 06/2018
// Détecteur de niveau haut et bas actionnant la pompe.
// Une sécurité (basée sur le temps de pompage) l'arrête
// jusqu'au prochain redémarrage, après coupure de l'alim.
// Cette version comporte une résistance de 220k entre +
// et "entrées", l'électrode de fond étant mise à la masse.
// Plus sensible et la valeur de la résistance n'est pas critique.
//------------------------------------------------------------------
/* Schéma:
*/
const int maxTime = 700; // Temps de pompage max. (en secondes div 2 pour l'Arduino, car delay(2000) ). Mais à ajuster en fonction de l'ATtiny
const int sortiePin = 4; // N° de la broche de sortie pour le relai ( 4 pour l'ATtiny85, 13 pour les tests avec diode jaune intégrée à l'Arduino)
const int secuPin = 3; // N° de la broche de sortie pour la LED (allumée si sécurité déclenchée)
const int basPin = 1; // N° de la broche d'entrée niveau bas (1 à 12 pour l'Arduino)
const int hautPin = 2; // N° de la broche d'entrée niveau haut ( " )
unsigned long timeON; // Compte du temps de pompage
boolean halt; // Arrêt sécurité définitif si timeON > maxTime
boolean on; // La pompe tourne si true
// Initialisations:
// ----------------
void setup() {
pinMode(sortiePin, OUTPUT);
pinMode(secuPin, OUTPUT);
pinMode(basPin, INPUT);
pinMode(hautPin, INPUT);
//digitalWrite(basPin, HIGH); // Activer la résistance de sortie interne pour inverser le bit
//digitalWrite(hautPin, HIGH); // et éviter la résistance externe, mais moins sensible...
digitalWrite(secuPin, LOW);
halt = false; // Sécurité
on = false; // Pompage
timeON = 0;
}
// Boucle "infinie":
// -----------------
void loop() {
// Sondes Haut ET Bas à sec (entrées HIGH) => pompe mise en marche:
if ((digitalRead(hautPin)==true)&&(digitalRead(basPin)==true)) {
if (halt == false) {on = true;};
}
// Sondes Haut ET Bas dans l'eau => arrêt de la pompe:
if (((digitalRead(hautPin)==false))&&((digitalRead(basPin)==false))) {
on = false;
timeON = 0; // Réinitialiser le chrono. sécurité
}
// Dans le cas OU, laisser en l'état (ON ou OFF, car montée ou descente en cours).
// Sécurité:
if (timeON > maxTime) { // La pompe tourne trop longtemps (crépine bouchée, plus d'eau, etc.)
halt = true;
digitalWrite(secuPin, HIGH);
}
else {
if (on) {timeON++;} // Décompter
// Si "on" et pas "halt" => pompage:
if ((on == true)&&(halt == false)) {
digitalWrite(sortiePin, LOW);
} // Relai activé avec sortie LOW (pompe en marche)
else {
digitalWrite(sortiePin, HIGH);
}
delay(2000); // 2 secondes entre chaque lecture pour l'Arduino
}