MicroPython-Hack-relais

Ce que nous faisons

Le prochain circuit est une sorte de test. Nous allons combiner ce que nous avons appris à propos de l'utilisation du transistor dans le montage moteur pour contrôler un relais.

Un relais est un interrupteur mécanique contrôlé électriquement. A l'intérieur de la petite boîte il y a un électro-aimant qui, une fois alimenté, enclenche l'interrupteur (souvent avec un cliquetis sonore).

Vous pouvez acheter des relais dont la taille varie du quart de celui présent dans ce kit d'apprentissage à celle d'un frigo, chacun capable de commuter une certaine quantité de courant.

Ils sont très amusants parce qu'ils comportent des éléments mécaniques. Bien que, jusqu'à maintenant, tout ce silicium avec lequel nous avons bricolé est vraiment amusant, quelquefois vous voulez juste brancher des interrupteurs pour contrôler quelque chose de magnifique.

Les relais vous offrent la possibilité d'y rêver pour ensuite le contrôler avec votre PyBoard.

Le montage

Le matériel nécessaire

Diode (1N4001)
x1

disponible chez MCHobby

Transistor P2N2222AG (to92)
x1

disponible chez MCHobby

Fils

disponible chez MCHobby

 

Résistance de 560 Ohms (vert-bleu-brun)
x2

disponible chez MCHobby

Résistance de 2.2K Ohms (rouge-rouge-rouge)
x1

disponible chez MCHobby

LED Rouge
x1

disponible chez MCHobby

 

LED Verte
x1

disponible chez MCHobby

Relais (SPDT)
x1

disponible chez MCHobby

 

Tous ces éléments sont disponibles dans le Kit Ardx proposé sur shop.mchobby.be.

Présence de la diode

La diode 1N4001 est utilisé comme diode anti-retour (aussi dit "en roue libre"), cette diode sert a court-circuiter la pointe de tension renvoyée par le relais lorsque celui-ci est désactivé. Lorsque l'on déconnecte une charge d'un circuit, celle-ci rend l'énergie qu'elle à accumulée au circuit (comme c'est un processus de réaction, la polarité est inversée).

Attention VIN = 5volts

Vous aurez remarqué que nous utilisons VIN (tension d'alimentation de la PyBoard) et que cette dernière est justement à 5 volts. Les 5 volts nécessaires sont fournit via la connexion USB de la PyBoard.

Vous noterez également que les LEDs sont alimentées en 5 Volts, raison pour laquelle nous utilisons une résistance de 470 Ohms (ou 330 Ohms) pour limiter le courant.

Schéma

Montage

Made with - réalisé avec - Fritzing fritzing.org

Note: Si vous ne disposez pas de résistance de 560 Ohms, vous pouvez les remplacer par des résistances de 330 Ohms (comme sur le montage ci-dessus).

Le code

Dès la mise sous tension du montage, une des deux LEDs doit être allumée (la rouge selon le montage).

Le programme ci-dessous active le relais pendant une seconde toutes les 5 secondes... de sorte que l'autre LED s'allume pendant une période de 1 seconde à chaque fois.

# Contrôle d'un relais branché sur le X8
from pyb import delay

# Déclaration et initialisation des broches
RELAY_PIN = pyb.Pin.board.X8
p = pyb.Pin( RELAY_PIN, pyb.Pin.OUT_PP )
p.low()

def RelayOff():
    p.low()

def RelayOnThenOff():
	# Boucle infinie, répète le cycle toutes les 5 secondes
    while True:
	    # Active le relay pendant une seconde
        p.high()
        delay( 1000 )
        p.low()
        # Attend 4 secondes
        delay( 4000 )


# RelayOff()
RelayOnThenOff()

Notre programme contient une petite fonction RelayOff() dont l'appel est mis en commentaire à l'aide du caractère dièse.

Si vous voulez arrêter le programme sur votre PyBoard, il suffit de modifier les appels de fonction comme suis:

RelayOff()
# RelayOnThenOff()

Et de re-téléverser votre programme sur la carte pour arrêter le fonctionnement du relais, la broche X8 reste maintenue à l'état low (bas) par la fonction relayOff()

Cela ne fonctionne pas?

Voici 3 choses à essayer.

Rien ne semble se passer

Le code de l'exemple utilise la broche X8, avez-vous bien branché le transistor sur la broche X8?

Pas de cliquetis ?

La partie du circuit relative au transistor ou à la bobine du relais ne fonctionnent pas.

Vérifiez que le transistor soit correctement raccordé et la diode dans le bon sens.

Ne fonctionne pas correctement

Le relais inclus est destiné à être soudé sur une carte. Vous pourriez avoir besoin de presser dessus pour vous assurer qu'il fonctionne (il peut occasionnellement se déloger)

Faire encore mieux

Voir l'impulsion électromagnétique de retour

Replacez la diode avec une LED. Vous la verrez s'illuminer brièvement à chaque fois que la bobine du relais renvoie une pointe de tension lorsque celui-ci s'éteint (se coupe).

Made with - réalisé avec - Fritzing fritzing.org

Notez que la diode LED est montée en sens non passant, c'est a dire avec la patte la moins longue (le "-") sur le +5Volts -ET- la patte la plus longue (le "+") sur le transistor.

Lorsque le relais rendra l'énergie accumulée au circuit (lors que la coupure de son alimentation), il le fera en réaction et donc en opposition de polarisation. C'est ce qu'on appelle l'effet transitoire... transitoire parce qu'il ne dure qu'un bref instant.

Par conséquent, durant l'effet transitoire, la côté transistor sera polarisé positivement par le relais et le côté +5 volts sera polarisé négativement. Du coup, la LED placée en parallèle sur le relais deviendra passante et absorbera l'énergie de l'effet transitoire en la transformant en "lumière" :-)

Sans cette diode, c'est le transistor qui devrait prendre en charge cet effet transitoire... et généralement, le transistor n'apprécie pas du tout le job! Sans une diode anti-retour (aussi dite "en roue libre"), votre transistor rendrait rapidement l'âme.

Classe PullUpButton

Voici une petite classe dont le but est de détecter UNE SEULE FOIS la pression d'un bouton.

La méthode is_pressed() permet de capturer la pression d'un bouton sur une entrée, et retourne True lorsque l'entrée passe au niveau bas (lorsque le bouton est pressé).

""" Classe pour gérer un bouton pull-up sur une broche X. 
    Détecte lorsque la broche passe à 0 """
class PullUpButton:
    p = None # Pin object
    state = None # Last known state

    def __init__( self, button_pin ):
        self.p = pyb.Pin( button_pin, pyb.Pin.IN, pull=pyb.Pin.PULL_UP )
        self.state = self.p.value()
    
    def is_pressed(self):
        """ vérifie si le bouton est pressé / détecte le changement
		    d'état. Ne sera signalé qu'une seule fois! """
        val = self.p.value()
        result = False
        if val != self.state:
            # relecture dans 10 ms (deboucing)
            pyb.delay( 10 )
            val2 = self.p.value()
            if val == val2: # valeur stable :)
                self.state = val
                result = (val == 0) # Is pressed
        return result

La détection de la pression se fait comme suit:

b = PullUpButton( pyb.Pin.board.X5 )
while True:
    if b.is_pressed():
        print('le bouton a été enfoncé')

Vous pouvez remarquer que le message "le bouton a été enfoncé" n'apparaît qu'une seule fois lorsque vous pressez le bouton.

Limite de cette implémentation:
Si votre programme fait beaucoup de traitement et que les appels sont trop occasionnel ALORS l'utilisateur pourrait presser sur le bouton entre deux appels à is_pressed() et dans ce cas, l'action n'est pas détectée.

Réaliser un télérupteur

En ajoutant simplement un petit bouton poussoir sur la broche X5, nous allons avoir l'opportunité de réaliser un télérupteur.

Appuyer dessus et le relais s'active, ré-appuyez sur le bouton et le relais se désactive.

Made with - réalisé avec - Fritzing fritzing.org

Comme vous pouvez le constater sur le montage ci-dessus, le bouton ramène la broche X5 à la masse lorsque celui-ci est pressé.

# Controle d'un relais branché sur X8 à l'aide du bouton branché sur X5
# Contrôle d'un relais branché sur le X8
from pyb import delay

# Relais
RELAY_PIN = pyb.Pin.board.X8
relais = pyb.Pin( RELAY_PIN, pyb.Pin.OUT_PP )
relais.low()

""" Classe pour gérer un bouton pull-up sur une broche X. 
    Détecte lorsque la broche passe à 0 """
class PullUpButton:
    p = None # Pin object
    state = None # Last known state

    def __init__( self, button_pin ):
        self.p = pyb.Pin( button_pin, pyb.Pin.IN, pull=pyb.Pin.PULL_UP )
        self.state = self.p.value()
    
    def is_pressed(self):
        """ vérifie si le bouton est pressé / détecte le changement
		    d'état. Ne sera signalé qu'une seule fois! """
        val = self.p.value()
        result = False
        if val != self.state:
            # relecture dans 10 ms (deboucing)
            pyb.delay( 10 )
            val2 = self.p.value()
            if val == val2: # valeur stable :)
                self.state = val
                result = (val == 0) # Is pressed
        return result

# Bouton
BTN_PIN = pyb.Pin.board.X5
b = PullUpButton( BTN_PIN )

# Corps du programme
while True:
    if b.is_pressed():
		if relais.value() == 1:
			relais.low()
		else:
		    relais.high()

Réaliser un temporisateur

Toujours avec le bouton poussoir banché sur la broche X5, nous allons aussi avoir l'opportunité de réaliser un temporisateur.

Appuyer dessus et le relais fonctionnera pendant un temps imparti de 10 secondes (dans la réalité, ce serait plusieurs minutes).

Made with - réalisé avec - Fritzing fritzing.org

Comme vous pouvez le constater sur le montage ci-dessus, le bouton ramène la broche X5 à la masse lorsque celui-ci est pressé.

# Contrôle d'un relais branché sur le X8
from pyb import delay

# Relais
RELAY_PIN = pyb.Pin.board.X8
relais = pyb.Pin( RELAY_PIN, pyb.Pin.OUT_PP )
relais.low()

""" Classe pour gérer un bouton pull-up sur une broche X. 
    Détecte lorsque la broche passe à 0 """
class PullUpButton:
    p = None # Pin object
    state = None # Last known state

    def __init__( self, button_pin ):
        self.p = pyb.Pin( button_pin, pyb.Pin.IN, pull=pyb.Pin.PULL_UP )
        self.state = self.p.value()
    
    def is_pressed(self):
        """ vérifie si le bouton est pressé / détecte le changement
		    d'état. Ne sera signalé qu'une seule fois! """
        val = self.p.value()
        result = False
        if val != self.state:
            # relecture dans 10 ms (deboucing)
            pyb.delay( 10 )
            val2 = self.p.value()
            if val == val2: # valeur stable :)
                self.state = val
                result = (val == 0) # Is pressed
        return result

# Bouton
BTN_PIN = pyb.Pin.board.X5
b = PullUpButton( BTN_PIN )

# Temps d'activation
ACTIVE_TIME_MS = 10000

t_on = 0 # Temps d activation restant
while True:
    if b.is_pressed():
        t_on = ACTIVE_TIME_MS 
    
    if t_on > 0:
        relais.high()
    else: 
        relais.low()
        
    t_on = t_on - 50
    if t_on <= 0:
        t_on = 0
    
    delay( 50 )

Plus, plus et encore plus

Dans les petites idées, vous pourriez utiliser le TMP36 et un relais pour refroidir le senseur à l'aide d'un petit ventilateur basse tension.

Vous pourriez également utiliser un transistor à la place du relais, cela vous permettrait de contrôler le ventilateur en PWM et de réaliser un asservissement.

---

Source: Micro Python Intro écrit par/written by Damien P.George

Traduit par Meurisse D. pour MCHobby.be - Translated by Meurisse D. for MCHobby.be

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.

Traduit avec l'autorisation de micropython.org - Translated with the authorisation of micropython.org