ATtiny85 - ACTIVER UN RELAIS AVEC DU RETARD

[Ph Blondé]

Nous connaissons le principe de l'activation d'un relais à partir d'un contact momentané (bouton-poussoir, ILS, etc.) et de faire en sorte que ce relais reste actif pendant un temps donné (2 s, 3 mn, etc.).
La réalisation électronique est souvent  simple ; il suffit d'aller sur le Net pour trouver moult montages sur la base du bon vieux NE555.

Cependant il arrive que l'on cherche à faire « coller » un relais APRES l'appui sur le bouton-poussoir ou l'ILS AVEC UN RETARD.

Certains me diront que c'est réalisable en électronique. C'est plus simple à dire qu'à faire, je veux bien, mais je n'ai pas que cela à faire (le reste du réseau attend).

J'ai donc utilisé un microcontrôleur Attiny85 pour cette réalisation. Il est tout de même plus facile de mettre ce montage au point puisqu'il s'agit de programmation, l'électronique (les composants) étant réduite au minimum. De plus si je veux faire varier les temps de temporisation, il me suffit de modifier une valeur dans le programme et de le recharger dans l'Attiny85.



Quel que soit les temps de retard « à l'allumage » souhaités, le scénario est toujours le même:

    - Activation d'un relais en instantané ou avec un délai compris, ici, entre 1 s et 10 mn.

    - Commande à partir d'un contact momentané  (ILS, contact quelconque, bouton-poussoir) par mise au 0V (masse).

    - Réglage un tantinet précis : choix porté sur une résistance variable multi-tours (25 tours).

    - Sortie sur relais 5V pour éviter d'avoir plusieurs types d'alimentation. Sa consommation doit correspondre à la possibilité d'une broche de l'Attiny85 : inférieure à 40mA.

    - Activation du relais pendant au moins 1 s.

    - Interdire la prise en compte d'une nouvelle détection pendant 15 s après l'activation du relais (cas du passage des ouagons ou des voitures du train lui-même).

    - Indications par LEDs de la temporisation en cours, du basculement du relais et de l'attente avant une nouvelle détection.

    - Alimentation en 5V pour tout.


En résumé et en schéma :

[Ph Blondé]

Le schéma électronique est simple :

- Une entrée (commande) est mise à la masse (0V).

- L'optocoupleur 4N35 voit sa LED d'entrée s'allumer et son transistor de sortie devenir passant.

- La broche 2 de l'Attiny85 était maintenue au + 5V par la résistance de 10k ; le transistor du 4N35 devenu passant met cette broche à la masse (0V) ; ce changement d'état est pris en compte par l'Attiny85.

- La valeur du retard est calculée en fonction de celle de la tension prise sur le curseur de la résistance variable de 10k par la broche 3.

- Pendant tout le temps de la temporisation, une LED (rouge) clignote à chaque seconde.

- Lorsque le temps correspondant à cette valeur du retard s'est écoulé, le relais est actionné et une LED verte est allumée pendant 1,5 s ; les deux s'éteignent ensemble. Le relais est un modèle REED car peu gourmand  et compatible avec le courant maxi que peut supporter une broche de l'Attiny ; cela évite l'emploi d'un transistor.

- Une seconde temporisation de 15 s est enclenchée avant de pouvoir prendre en compte une nouvelle commande en entrée ; la LED rouge clignote à chaque seconde.

Liste des composants pour 1 montage :
    o   2 résistances de 470 Ohms, 1/4 W
    o   1 résistance variable multi-tours (15 ou 25) de 10k
    o   2 LEDs (1 rouge et 1 verte)
    o   1 relais REED en boîtier SIL 5V (1 contact) ; nota : sa consommation est de 10 mA.
    o   1 optocoupleur 4N35, 1 support 6 broches
    o   1 ATtiny85, 1 support 8 broches.
    o   Borniers 2 pôles (entrée, sortie, alimentation) ou souder directement les fils...
    o   1 plaquette à bandes de prototypage (ou 1 circuit imprimé ... si vous le faites.

[Ph Blondé]

Le programme est, comme à mon habitude, une suite de commandes simples.

1.   Attente du signal de commande suite à une détection :
                   C'est une boucle qui tourne tant que l'entrée est au plus.
                   Sortie de cette boucle si la commande d'entrée est à LOW.

2.   Temporisation avant activation du relais :
          Lecture de la tension présente sur le curseur de la résistance variable.
          Transformation (map) en une valeur de retard comprise entre 0 à 600 (dans mon cas) ; 10 mn donnent 600 (600 s).
          Temporisation par une boucle while
                    La LED rouge s'allume 200 ms (LOW) puis s'éteint 800 ms (HIGH) ; donc la durée d'une boucle est de 1 s.
                    Incrémentation d'un compteur de boucle.
                    Sortie de la boucle lorsque valeur de ce compteur dépasse celle du retard.
                    Supposons que la valeur du retard soit 600, alors il y aura 600 passages sur cette boucle d'une durée de                                                                             1 s et donc on aura bien 600 x 1 s qui correspondent bien aux 10 mn. Cette solution pour éviter de se trimbaler des valeurs de 600 000 ms dans le « delay ».

3.   Activation du relais :
          La LED rouge est éteinte (HIGH).
          La LED verte est allumée par mise à 0V (LOW)
          Le relais est activé par mise à 0V (LOW)
          Délai de 1500 ms (après essais). Sur ce point, rien n'empêche de faire également une durée variable de fonctionnement du relais.
          Le relais est désactivé (HIGH)
          La LED verte est éteinte (HIGH)

4.   Temporisation du système pour 15 s :
          Ceci a été mis en place après essais pour un montage dont le retard avant déclenchement était court (<= 15 s) ; on évite ainsi de prendre en compte une détection « parasite (cas de l'IR) due à un wagon ou à une voiture du train qui passe encore devant le détecteur alors que le relais a été activé et vient d'être désactivé.
          C'est exactement la même boucle que celle de temporisation du relais mais limitée à 15 s.
La LED rouge s'allume 800 ms (LOW) puis s'éteint 200 ms (HIGH) ; donc également 1 s à chaque passage dans la boucle.

5.   Retour à 1.

Code Sélectionner Étendre

// MAJ 01-12-2021
// Alimentation de l'ensemble en 5V
// ATtiny85 : attention à graver la séquence d'initialisation avant de télécharger le programme!
// 8 MHz

//**********************************************************************************************
// PRINCIPE DE FONCTIONNEMENT DU MONTAGE

// Ce module réagit en recevant un signal de détection (IR) au passage d'un train.
// La détection est déclenchée au passage d'un train sur le modulino UFO87.
// Après un retard ajustable entre 1s et 10mn (temporisation), un relais est activé pendant 1s.
// Ce relais pourra déclencher une animation sur un modulino (ou autre).
// Le temps de temporisation est déterminé par lecture de la valeur d'une résistance variable.
// Cette résistance variable est une résistance variable de 25 tours.
// Dans la phase de temporisation une Led rouge clignote une fois par seconde.
// A l'issue du temps de temporisation, le relais et une Led verte s'activent pendant 1s.
// Le relais (REED 1T) et les Leds sont activés si leur broche est mis à 0 (LOW).
// Un train long ne doit activer qu'une fois le système.
// Un retard de 15s est imposé avant toute prise en compte d'une autre détection.
// Nota : le détecteur IR est un kit de chez Microprocessor (5 détections IR).

//**********************************************************************************************
// PRINCIPE DE LA BOUCLE DE TEMPORISATION

// Lecture de la valeur de la résistance variable qui fixe la valeur du retard
// Valeurs du retard : 0V donne 1 seconde et 5V donne 600s (10mn > 600s)
// Le nombre de boucles à faire est égal à la valeur du retard en secondes (utilisation de map)
// Chaque boucle dure 1 seconde. Exemple : 10 boucles donnent 10 secondes
// La Led rouge clignote pour signaler l'activation de la boucle

//**********************************************************************************************
// REPERAGE DES BROCHES DE L'ATtiny85

// LAISSER LIBRE - RESET                BROCHE N° 1 > RESET
// Detection_Train                      BROCHE N° 2 > VALEUR 3 OU A3 POUR LE CODE
// Resistance_Variable_Valeur_Retard    BROCHE N° 3 > VALEUR 4 OU A2 POUR LE CODE
// Moins alimentation                   BROCHE N° 4 > GND (0V)
// Relais_De_Sortie                     BROCHE N° 5 > PWM VALEUR 0 POUR LE CODE
// Led_Rouge_Temoin_Temporisation                   BROCHE N° 6 > PWM VALEUR 1 POUR LE CODE
// Led_Verte_Témoin_Activation_Relais   BROCHE N° 7 > VALEUR 2 OU A1 POUR LE CODE
// Plus alimentation 5V                 BROCHE N° 8 > 5V

//**********************************************************************************************
// DESCRIPTION DES DONNEES

//ENTREES
const int Detection_Train = 3; // BROCHE N° 2
int Etat_Detection_Train;

const int Resistance_Variable_Valeur_Retard = A2; // BROCHE N° 3
int Valeur_Retard;

// SORTIES
const int Relais_De_Sortie = 0; // BROCHE N° 5

const int Led_Rouge_Temoin_Temporisation = 1; // BROCHE N° 6
const int Led_Verte_Temoin_Activation = 2; // BROCHE N° 7

//**********************************************************************************************
void setup()
{
pinMode (Relais_De_Sortie, OUTPUT);
digitalWrite (Relais_De_Sortie, HIGH);

pinMode (Led_Rouge_Temoin_Temporisation, OUTPUT);
digitalWrite (Led_Rouge_Temoin_Temporisation, HIGH);

pinMode (Led_Verte_Temoin_Activation, OUTPUT);
digitalWrite (Led_Verte_Temoin_Activation, HIGH);

pinMode (Resistance_Variable_Valeur_Retard, INPUT);

pinMode (Detection_Train, INPUT);
digitalWrite (Detection_Train, HIGH);
}
//**********************************************************************************************
void loop()
{
  Detection ();
}

//**********************************************************************************************
void Detection ()
{
// Attente du signal de détection

do
  {
    Etat_Detection_Train = digitalRead (Detection_Train);
  }
while (Etat_Detection_Train == HIGH);
Temporisation ();
}

//**********************************************************************************************
void Temporisation ()
{
Valeur_Retard = analogRead (Resistance_Variable_Valeur_Retard);
Valeur_Retard = map (Valeur_Retard, 0, 1023, 0, 600);

int Delais_Temporisation = 0;
while (Delais_Temporisation < Valeur_Retard)
  {
    digitalWrite (Led_Rouge_Temoin_Temporisation, LOW);
    delay (200);
    digitalWrite (Led_Rouge_Temoin_Temporisation, HIGH);
    delay (800);
    Delais_Temporisation ++;
  }
Activation ();
}

//**********************************************************************************************
void Activation ()
{
// Activation du relais et de la Led verte

digitalWrite (Led_Verte_Temoin_Activation, LOW);
digitalWrite (Relais_De_Sortie, LOW);
delay (1500);
digitalWrite (Relais_De_Sortie, HIGH);
digitalWrite (Led_Verte_Temoin_Activation, HIGH);
Desactivation ();
}

//**********************************************************************************************
void Desactivation ()
{
// Désactivation du système durant 15s.

int Delais_Desactivation = 0;
while (Delais_Desactivation <= 15)
  {
    digitalWrite (Led_Rouge_Temoin_Temporisation, LOW);
    delay (800);
    digitalWrite (Led_Rouge_Temoin_Temporisation, HIGH);
    delay (200);
    Delais_Desactivation ++;
  }
Detection ();
}



Je vous joins en PJ les fichiers en .ino et en .doc

[Ph Blondé]

Ici 5 montages identiques pour des temps différents de temporisation avant activation d'animations via les relais REED.

Toujours pour 5 montages, les dimensions du circuit sont de 11 cm (de gauche à droite) et de 10 cm pour la hauteur. On peut certainement diminuer ces dimensions en faisant un circuit imprimé mais les relais prennent toujours un peu de place.

Pour moi, j'ai ajouté des "jump" (jaunes et bleu) en entrée au niveau des commandes. Cela me permet d'isoler les montages non utilisés

Le coût d'un module : entre 6,10 et 10,85€ (dont 3,8 à 5,20 € pour le circuit imprimé à bandes de 10 x 16 cm), suivant le fournisseur et sans les borniers (toujours plus chers que les composants ces machins-là  ).

Bon amusement et bon train

[Attiny]

Bonjour Philippe

Merci ce nouvel article qui met en avant l'utilisation de l'ATtiny85 et de l'Arduino en général.

Je viens juste d'essayer ton montage reproduit sur une plaque d'essai. Fonctionnement parfait.
J'ai apprécié en particulier l'astuce du clignotement de la LED rouge!...

Pour inciter les personnes intéressées mais qui n'ont pas le matériel  pour programmer cette petite puce (une simple carte Uno et quelques fils à relier sur une plaque d'essai) , je suis disposé à programmer des ATiny85  avec ton code  et les envoyés à prix coutant plus frais de port.
Bonne fin de journée

[Ph Blondé]

Bonjour Philippe
Merci ce nouvel article qui met en avant l'utilisation de l'ATtiny85 et de l'Arduino en général.

Je viens juste d'essayer ton montage reproduit sur une plaque d'essai. Fonctionnement parfait.
J'ai apprécié en particulier l'astuce du clignotement de la LED rouge!...
Bonne fin de journée

Bonjour et merci pour l'appréciation 

Effectivement j'avais déjà eu des problème avec de grosses valeurs dans "delay".
Et je ne sais pas pourquoi, mais à force de retourner cela dans la tête, j'ai penser à cette solution d'une boucle d'une durée de 1 s à chaque passage.

Ce montage sera placé dans un modulino ; à voir à Périgueux les 16 et 17 avril prochains. 

[Attiny]

Ce clignotement est une méthode vraiment pratique pour visualiser une temporisation!
Je vais la proposer à un collègue  pour tester ses temporisations pour déclencher l'ouverture du parachute de micro fusée.

Il y aurait une exposition de train en avril à Périgueux?

[matabiau]

Bravo pour cette réalisation où tout est pris en compte, expliqué, réalisé :
- schéma de principe simple et clair
- soft parfaitement documenté
- opto à l'entrée permettant si besoin de séparer totalement le monde perturbé (longueurs des fils, parasites de traction, etc) du monde sensible (micro-contrôleur)
- réglages simples par potar ou dans le programme
- visualisation claire des états
- sortie par relais (mêmes qualités que l'entrée)
- montage très soigné
bref, un bel exemple de pragmatisme 
c'est du boulot de pro 

[Ph Blondé]

Merci Matabiau,
Mais quand je vois ton réseau, c'est aussi un travail de pro.

[Ph Blondé]

...
Il y aurait une exposition de train en avril à Périgueux?

Bonjour Attiny,
Il y aura un rassemblement de modulinos.
En espérant "qu"ils" ne nous remettent pas en confinement.
Je ne sais pas s'il y aura autre chose

[Attiny]

Bonjour Philippe et bonjour à tous.

Je viens de terminer la simulation de ton projet sur Wokwi.
Elle est consultable en utilisant ce lien.
On peut modifier la tempo en jouant sur le potentiomètre, l'appui sur le BP représente la détection du train et la Led bleue le relais.
Pour lancer la simulation il suffit de cliquer sur la flèche verte.
En espérant que cela puisse servir et motiver des membres du Forum de se lancer dans l'Arduino.

Bonne continuation à tous

[Ph Blondé]

Bonjour Philippe et bonjour à tous.

Je viens de terminer la simulation de ton projet sur Wokwi.
Elle est consultable en utilisant ce lien.
On peut modifier la tempo en jouant sur le potentiomètre, l'appui sur le BP représente la détection du train et la Led bleue le relais.
Pour lancer la simulation il suffit de cliquer sur la flèche verte.
En espérant que cela puisse servir et motiver des membres du Forum de se lancer dans l'Arduino.

Bonne continuation à tous

           
Merci à toi,
Et ça tombe bien car je dois faire ce montage qui sera commandé par radiocommande ; commande de deux projecteurs LEDs en extérieur et dans le garage avec des temporisations différentes (plus log dans le garage).
Les ordres de commande seront donc donnés au niveau de ton BP.
Merci encore pour le lien et donc le code, je gagne du temps   

[Attiny]

De rien Philippe, c'est toi qui a fait la plus grande part du travail