Piloter des Relais ou des MOSFEts à l'aide d'un Module MCP23008 ou MCP23017

 

Piloter des Relais ou des MOSFEts

à l'aide d'un Module MCP23008 ou MCP23017

Qu'il s'agisse de piloter un certain nombre de relais ou de MOSFETs, le nombre de sorties d'un ARDUINO est un facteur plutôt limitant. Jusqu'à 4 ou 8 voies c'est envisageable, au delà cela devient problématique.

Nos microcontrôleurs habituels disposent rarement de plus de 16 sorties utilisables, et l'on a pas forcément envie de s'encombrer d'une carte ARDUINO MEGA.

La solution est d'employer un expander I2C du genre MCP23017. Le nombre de sorties nécessaires au niveau du microcontrôleur sera donc réduit à seulement 2 :

• ARDUINO : A4 & A5
• ESP8266 : GPIO4 & GPIO5
• ESP32 : GPIO21 & GPIO22

On emploie souvent un module expander I2C PCF8574 lorsque l'on veut piloter un écran LCD alphanumérique. Il suffit de souder le module à l'arrière du LCD, et le tour est joué :

Alors pourquoi ne pas adopter la même solution pour un module à relais ou à MOSFETs ?

Pour mes réalisations j'ai choisi le MCP23008 et le MCP23017, plus universels et plus modernes que le PCF8574 et le PCF8575.

Le PCF8574 et le PCF8575 ont des performances limitées en courant de sortie (50mA à l'état bas et 100µA à l'état haut. Ils seraient donc incapables de piloter un module à relais.

C'est pour cette raison que je leur préfère largement les MCP23008 et MCP23017, qui offrent de plus la possibilité de configurer leurs entrées avec des résistances de PULLUP internes, et possèdent une broche d'interruption.

Un MCP23008 ou un MCP23017 peut être alimenté sous 5V, mais également sous 3.3V.

Voici un module MCP23017 à 16 entrées / sorties :

Vue de dessous

Ce module ne dispose pas de trous de fixation. Il sera donc câblé en l'air, ou collé. Ce n'est pas une solution très esthétique et la fiabilité ne sera pas optimale.

Ces modules existent sous d'autres formes, plus facile à fixer :

Il faut choisir le modèle qui simplifiera au mieux le câblage et la mécanique.

Dans la suite de cet article, nous allons appeler ces modules "le module noir" et "le module vert".

1. Câblage

Je présente ici deux solutions :

• relier un module MCP23017 du commerce avec le module relais à l'aide d'un câble maison
• enficher un module MCP23008 ou MCP23017 maison sur le module relais

1.1. Fabriquer un câble DUPONT multipoints

Tout d'abord, pour une réalisation fiable, je déconseille totalement d'utiliser des fils DUPONT du commerce pour relier deux modules (MCP23017 et relais) entre eux. C'est la meilleure source de faux contacts qui soit. Il est préférable de fabriquer un câble à l'aide de boîtiers DUPONT multipoints :

boîtiers DUPONT 8 points

On en trouve différents modèles, jusqu'à 8 pins, y compris à double rangée.

On aura besoin de contacts à sertir :

On aura aussi besoin d'une pince. Des kits sont disponibles :

Fabriquer des câbles multi-conducteurs avec des connecteurs DUPONT n'est pas une mince affaire, mais ce n'est pas insurmontable : 

On voit ici deux cartes reliées par un câble à 17 conducteurs réalisé a l'aide de boîtiers DUPONT à 6 et 5 broches. Ce n'est pas très esthétique mais c'est une solution qui fonctionne.

Dans la suite de ce document, j'utilise des symboles schématiques de connecteurs DUPONT à 10 broches, ou même 17 broches. On trouve facilement des barrettes à souder pour PCB, mâles ou femelles, jusqu'à 40 points, mais on ne trouve pas de boîtiers DUPONT possédant plus de 8 points. On pourra utiliser plusieurs boîtiers pour réaliser un câble de plus de 8 points :

• 10 points : 2 x 5 points
• 17 points : 2 x 6 points + 5 points

1.2. Module expander DIY

Une autre solution, qui simplifie grandement le câblage et dont la fiabilité sera probablement supérieure, est de réaliser un module expander maison, avec un MCP23008 ou un MCP23017, et un connecteur femelle adapté qui vient s'enficher directement sur le connecteur mâle du module relais.

J'en ai développé un pour mon module à 16 MOSFETs : voir 3.3. Module MCP23017 DIY :

Module MCP23017 DIY

Pour une réalisation en exemplaire unique, il est facile de réaliser ce genre de module sur une plaquette à pastilles :

Voir ici : Développement électronique ARDUINO

Paragraphe 8.7. Le montage sur plaquette à pastilles

2. Module à relais

En général les modules relais possèdent un connecteur d'alimentation. Parfois, un cavalier est présent sur ce connecteur (photo ci-dessous). Il permet d'alimenter les bobines des relais à l'aide de la tension VCC présente sur le connecteur d'entrée, sans utiliser le connecteur d'alimentation. Or cette tension VCC provient souvent de la carte ARDUINO elle-même. Si l'ARDUINO est alimenté par sa broche VIN ou par le connecteur USB, le courant disponible sera insuffisant pour alimenter 8 ou 16 relais simultanément.

Il vaut mieux prévoir un câble d'alimentation séparé, provenant directement d'une alimentation 5V ou 12V. Pour cette alimentation, prévoir 375mW par relais, donc environ 3W pour 8 relais, 6W pour 16 relais.

Si le module est équipé de relais 12V, retirer le cavalier est indispensable, car il faudra appliquer du 12V entre les broches JD-VCC et GND.

Les modules relais ont évolué, grâce je pense à des optocoupleurs plus sensibles. Le dernier que j'ai acheté (4 relais) demande un courant de commande de seulement 1.4mA. Un module 16 relais aura donc besoin de 22mA au total, ce qu'un ARDUINO est parfaitement capable de fournir.

Les modèles plus anciens demandaient souvent 10mA.

2.1. Module à 8 relais

Le connecteur d'entrée possède 10 broches :

• GND
• 8 entrées
• VCC

2.1.1. Expander du commerce

Pour commander ce module relais à l'aide d'un expander il nous faudrait un module équipé d'un MCP23008, malheureusement introuvable, à moins de le réaliser soi-même. Nous pouvons nous rabattre sur un MCP23017 dont on n'utilisera que 8 sorties.

Avec le module MCP23017 vert, le câble sera simple à réaliser :

4 boîtier DUPONT à 5 broches seront nécessaires.

Voici une petite vidéo:

J'ai utilisé le module vert, et deux câbles réalisés à l'aide de quatre boîtiers DUPONT à 5 broches.

Les relais sont alimentés en 12V par les broches JD-VCC et GND (à droite), car ce sont des modèles 12V.

Et voici le code correspondant :

#include <Wire.h>
#include "Adafruit_MCP23017.h"

Adafruit_MCP23017 mcp;

void setup() {
  mcp.begin();      // use default address 0
  for (int n = 0 ; n < 8 ; n++) {
    mcp.pinMode(n, OUTPUT);
    mcp.digitalWrite(n, HIGH);
  }
}

void loop() {
  // activer relais 1 à 8
  for (int n = 0 ; n < 8 ; n++) {
    mcp.digitalWrite(n, LOW);
    delay(200);
    mcp.digitalWrite(n, HIGH);
    delay(200);
  }
}

Comme ce sont des relais activables par un niveau bas, on les désactive dans la fonction setup() :

    mcp.digitalWrite(n, HIGH);

Avec le module MCP23017 noir, VCC sera relié par un fil séparé, car VCC et GND sont situés sur deux rangées différentes. Ce n'est pas une excellente solution. Les risques de faux contacts sur un connecteur DUPONT à 1 broche sont plus importants :

2.1.2. Expander DIY

J'ai réalisé un module expander à l'aide d'un MCP23008 :

Il possède les deux connectiques, pour un module à 4 relais (6 broches) et pour un module à 8 relais (10 broches).

l'adresse I2C (de 0x20 à 0x27) est sélectionnable à l'aide d'un DIP-SWITCH :

Il a été réalisé sur une plaquette à pastilles. La réalisation souffre d'une petite erreur  : contrairement à ce qui était prévu, les connecteurs de sortie ont été soudés côté composants. Une fois en place sur le module à relais la carte se retrouve à l'envers. Ce n'est pas très esthétique, mais cela ne gène pas le fonctionnement :

Je me console en me disant que l'ensemble n'est pas plus épais que le module relais seul.

Le module MCP23008 déborde d'environ 1cm du module relais. Pour une réalisation plus compacte, il faudrait utiliser des composants CMS sur un PCB maison.

2.1. Module à 16 relais

Examinons une carte à 16 relais :

Le connecteur d'entrée possède 20 broches :

• 2 x GND
• 16 entrées
• 2 x 5V

Il possède en outre un bornier d'alimentation (12V car ce module est équipé de relais 12V).

Par contre, comme on peut le voir sur la photo, les entrées du module relais sont réparties sur deux connecteurs (entrées paires et entrées impaires) :

• rangée du haut : 5V, 2, 4, 6, 8, 10, 12, 14, 16, GND
• rangée du bas : 5V, 1, 3, 5, 7, 9, 11, 13, 15, GND

Le moins que l'on puisse dire est que le fabricant n'a pas pensé au câblage autrement qu'avec des fils DUPONT.

2.2.1. Expander du commerce

Celui-ci sera assez fastidieux à réaliser, que l'on utilise le module MCP23017 vert :

Ou que l'on utilise le module MCP23017 noir :

On peut se demander s'il ne vaut pas mieux utiliser 2 modules à 8 relais. Avec le module vert par exemple, qui dispose de broches VCC et GND pour chaque port A0-A7 et B0-B7. Pour ma part je n'hésiterais pas.

2.2.2. Expander DIY

Il ne serait pas bien compliqué de réaliser un module DIY à base de MCP23017, enfichable sur le module relais, comme précédemment.

3. Module à MOSFETs

Lorsque l'on commute des charges alimentées en tension continue (5V, 12V ou 24V), un relais n'est pas forcément le composant le plus adapté. Un MOSFET fera ce travail en silence, et avec une fiabilité supérieure.

Sa grille ne consomme aucun courant. Seule la résistance de PULLDOWN que l'on installe entre grille et source consomme : 50µA pour une résistance de 100KΩ sous 5V, à comparer avec les 70mA ou 150mA d'un relais..

J'avais présenté il y a un an deux modules à 8 et 16 MOSFETs :

Un Module à 8 ou 16 Mosfets

3.1. Module à 8 MOSFETs IRLZ44N

Un Module à 8 ou 16 Mosfets

Dans cet article cité précédemment je décrivais également un module à 8 MOSFETs IRLZ44N, réalisé sur plaquette à pastilles :

On peut également le piloter à l'aide d'un module MCP23017.

Sur cette photo il est équipé d'un connecteur DUPONT femelle, mais on peut également souder un connecteur mâle.

Avec le module MCP23017 vert :

Avec le module MCP23017 noir :

3.2. Module à 16 MOSFETs

Le module à 16 MOSFETs AO3400 était à l'époque destiné à commander 16 petits rubans de LEDs. Il était piloté par une carte ARDUINO PRO MINI et un expander SX1509 à 16 sorties PWM :

Un éclairage d'escalier à LEDs

Ce module va être à nouveau utilisé dans un autre projet pour commander des électrovannes 12V à l'aide d'un ESP32.

Problème : l'ESP32 ne dispose pas d'assez de sorties pour piloter 16 électrovannes et divers capteurs et LEDs.

Il est possible d'utiliser un module expander du commerce, comme s'il s'agissait d'un module à relais.

Pour rappel le brochage du module à 16 MOSFETs est le suivant :

• 1 : GND
• 2 à 17 : entrée N°1 à 16

Contrairement à un module relais, un module à MOSFETs n'a pas besoin d'alimentation (VCC) sur ses entrées.

3.2.1. Expander du commerce

Avec le module MCP23017 vert, le câblage est le suivant :

Avec le module MCP23017 noir, le câblage sera très peu différent :

3.2.2. Expander DIY

Pour mes propres besoins, plutôt que d'utiliser un module MCP23017 du commerce, j'ai développé un module pouvant s'enficher sur le module à 16 MOSFETs AO3400.

Il s'agit en quelque sorte d'un shield, comme on dit dans le monde ARDUINO.

Les sorties sont assignées comme ceci :

• 2 à 9 : port B0 - B7
• 10 à 17 : port A0 - A7

Les deux ports sont permutés. Cela m'a permis d'avoir un schéma plus clair est surtout un routage du PCB permettant de réduire la largeur de la carte, qui doit être de moins de 30mm pour pouvoir être enfichée à l'horizontale sur le module à MOSFETs, sans gêner l'accès au connecteur de sortie de celui-ci.

Il s'agit d'un MCP23017 DIL 28 pattes. Ce circuit peut être facilement essayé sur une breadboard, et sa réalisation sur une plaquette à pastilles ne poserait aucun problème.

Le groupe de 3 jumpers JP1 permet de changer l'adresse I2C (de 0x20 à 0x27) :

A0, A1 et A2 correspondent aux broches 15, 16 et 17 sur le schéma.

L'adresse est sélectionnée à l'aide de points de soudure :

Pour obtenir l'adresse 0x20 il faudra réunir les pastilles 1-2, 4-5, 7-8
Pour obtenir l'adresse 0x21 il faudra réunir les pastilles 2-3, 4-5, 7-8
Pour obtenir l'adresse 0x22 il faudra réunir les pastilles 1-2, 5-6, 7-8
Pour obtenir l'adresse 0x23 il faudra réunir les pastilles 1-2, 4-5, 8-9
Pour obtenir l'adresse 0x24 il faudra réunir les pastilles 2-3, 5-6, 8-9
etc.

Le dossier se trouve ici :

https://bitbucket.org/henri_bachetti/arduino-prototyping/src/master/mosfet-module/sot23-16-mcp23017/

3.3. Module à MOSFETs tout en un

Pour en terminer avec cet exposé : si l'on est motivé, il est possible de réaliser un module tout en un :

Ce module à I2C à 8 MOSFETs IRLU2905 est l'équivalent du module à 8 MOSFETs IRLZ44N, en version PCB avec des MOSFETs de taille plus réduite (boîtier IPAK ou TO251AA). La commande se fait par le bus I2C grâce à un MCP23008 (8 sorties).

Bien entendu on peut remplacer les IRLU2905 par des MOSFETs de son choix (IRLU024, IRLU8743, etc.). Le schéma restera identique, seule l'implantation sur la carte sera éventuellement à modifier, si l'on désire utiliser des IRLZ44N en boîtier TO220 par exemple.

Quelques référence sont données ici :

MOSFETS de puissance

Choisir de préférence un modèle ayant une tension VGSth la plus faible possible.

La carte est équipée d'un connecteur d'entrée JST XH à 4 broches (J1) :

• GND
• SDA et SCL
• VDD pour l'alimentation du MCP23008 (5v ou 3.3V)

Elle est également équipée de borniers :

• connecteur 10A d'alimentation de puissance (J2)
• 8 borniers 7A pour 8 charges

La broche VDD du connecteur d'entrée est limitée à 3A. Si les besoins sont supérieurs, utiliser le bornier 10A d'alimentation de puissance.

Un cavalier peut être mis en place sur J2 (bornes 2&3) si :

• les charges fonctionnent sous la même tension que VDD
• le courant est inférieur à 3A

Contrairement au module précédent, comme il y a de l'espace inoccupé sur la carte, l'adresse I2C (de 0x20 à 0x27) est sélectionnable à l'aide d'un DIP-SWITCH :

On remarque la présence de 3 résistances de PULLUP de 100KΩ qui polarisent les entrées A0 à A2 à VDD lorsque le DIP-SWITCH est ouvert. Ces résistances sont indispensables. Elles entraînent une consommation minime : 150µA sous 5V. On peut adopter une valeur de 470KΩ ou 1MΩ si l'on désire réduire cette consommation, mais le montage sera plus sensible aux parasites électromagnétiques.

Le dossier se trouve ici :

https://bitbucket.org/henri_bachetti/arduino-prototyping/src/master/mosfet-module/mcp23008-eight-mosfet/

4. Librairies

Voici les librairies pour le MCP23008 et MCP23017 :

MCP23008 : https://github.com/adafruit/Adafruit-MCP23008-library.git

MCP23017 : https://github.com/adafruit/Adafruit-MCP23017-Arduino-Library.git

Elles sont installables à partir du gestionnaire de bibliothèques de l'IDE ARDUINO.

Dans ses dernières version (2.0.0 et suivantes) la librairie Adafruit-MCP23017-Arduino-Library gère le MCP23008 et le MCP23017, y compris les versions SPI MCP23S08 et le MCP23S17.

Si l'on utilise cette dernière version les codes proposés dans les paragraphes suivants seront légèrement différents :

#include "Adafruit_MCP23017.h"

// à remplacer par

#include <Adafruit_MCP23X17.h>

 

#include "Adafruit_MCP23008.h"

// à remplacer par

#include <Adafruit_MCP23X08.h>

 

Adafruit_MCP23017 mcp;

// à remplacer par

Adafruit_MCP23X17 mcp;

 

Adafruit_MCP23008 mcp;

// à remplacer par

Adafruit_MCP23X08 mcp;

 

  mcp.begin();

  // à remplacer par

  mcp.begin_I2C();

D'autre part, la méthode begin() des versions 1.XXX accepte un argument allant de 0 à 7. Elle ajoute elle-même 0x20 pour obtenir l'adresse I2C, tandis que la méthode begin_I2C() doit recevoir l'adresse I2C (0x20 à 0x27).

5. Essais

Après avoir réalisé le câblage et l'avoir vérifié, un petit test avec une carte ARDUINO chargé avec le sketch I2C-Scanner permettra de vérifier que le MCP23017 ou le MCP23008 est bien vu sur le bus I2C à l'adresse voulue.

5.1. Essais du module MCP23008 DIY

Le module MCP23008 DIY

Je ne possède pas de module à 8 relais, mais voici le module PCP23008 enfiché sur un module à 4 relais :

Le câblage de la plaquette à pastilles (80mm x 30mm) est réalisé à l'aide de fil à wrapper.

Un premier essai avec une UNO chargée avec le sketch I2C-Scanner montre que la carte fonctionne :

Scanning...
Appareil I2C trouve a cette adresse 0x20  !
Fin

Testons d'abord le module MCP23008 seul. Ce petit sketch permet de faire clignoter une LED branchée entre les pins 1 (GND) et 2 du connecteur de sortie (on doit toujours placer une résistance en série avec une LED  : 220Ω à 1KΩ) :

#include <Wire.h>

#include "Adafruit_MCP23008.h"

#define RELAY       0

Adafruit_MCP23008 mcp;

  

void setup() {  

  mcp.begin();

  mcp.pinMode(RELAY, OUTPUT);

}

void loop() {

  mcp.digitalWrite(RELAY, HIGH);

  delay(500);

  mcp.digitalWrite(RELAY, LOW);

  delay(500);

}

Testons ensuite le module MCP23008 enfiché sur un module à 4 relais. Voici un petit code pour activer les relais un à un :

#include <Wire.h>

#include "Adafruit_MCP23008.h"

Adafruit_MCP23008 mcp;

void setup() {

  mcp.begin();      // use default address 0

  for (int n = 0 ; n < 4 ; n++) {

    mcp.pinMode(n, OUTPUT);

    mcp.digitalWrite(n, HIGH);

  }

}

void loop() {

  for (int n = 0 ; n < 4 ; n++) {

    mcp.digitalWrite(n, LOW);

    delay(1000);

    mcp.digitalWrite(n, HIGH);

  }

}

Voici le résultat :

5.2. Essais du module MCP23017 DIY

Le module MCP23017 DIY

Il s'agit d'un prototype sur PCB simple face, avec des straps (fils rouges). 

Le sélecteur d'addresse I2C

Les trois broches d'adresse sont reliées à GND par un pâté de soudure. L'adresse sera 0x20.

Le module en place

J'ai utilisé un connecteur femelle coudé car c'est un prototype simple face, sans trous métallisés. La carte est donc enfichée verticalement, ce qui est assez encombrant.

Souder un connecteur droit côté soudures est plutôt déconseillé. Le risque est d'arracher les pastilles en retirant le module.

Si l'on fait fabriquer le PCB par JLCPCB par exemple, on pourra souder un connecteur droit, sous la carte, avec soudures côté composants, et celle-ci sera à plat, au dessus de la carte à MOSFETs.

Le PCB du module à MOSFETs, lui, a été réalisé par JLCPCB.

Un premier essai avec une UNO chargée avec le sketch I2C-Scanner montre que la carte fonctionne :

Scanning...
Appareil I2C trouve a cette adresse 0x20  !
Fin

Testons d'abord le module MCP23017 seul. Ce petit sketch permet de faire clignoter une LED branchée entre les pins 1 (GND) et 2 du connecteur de sortie (on doit toujours placer une résistance en série avec une LED  : 220Ω à 1KΩ) :

#include <Wire.h>

#include "Adafruit_MCP23017.h"

#define LED       8

Adafruit_MCP23017 mcp;

  

void setup() {  

  mcp.begin();

  mcp.pinMode(LED, OUTPUT);

}

void loop() {

  mcp.digitalWrite(LED, HIGH);

  delay(500);

  mcp.digitalWrite(LED, LOW);

  delay(500);

}

Attention : le MCP23017 est limité à 25mA par sortie et 150mA au total. Il ne s'agit pas de le surcharger avec 16 LEDs consommant 20mA chacune, allumées simultanément. Il n'apprécierait probablement pas.

Testons ensuite le module MCP23017 enfiché sur la carte à MOSFETs équipée d'une LED (avec résistance de 1KΩ) sur chaque sortie. Voici un petit code pour allumer les LEDs en chenillard :

#include <Wire.h>

#include "Adafruit_MCP23017.h"

Adafruit_MCP23017 mcp;

void setup() {

  mcp.begin();      // use default address 0

  for (int n = 0 ; n < 16 ; n++) {

    mcp.pinMode(n, OUTPUT);

  }

}

void loop() {

  // allumer LEDs 1 à 8

  for (int n = 8 ; n < 16 ; n++) {

    mcp.digitalWrite(n, HIGH);

    delay(20);

    mcp.digitalWrite(n, LOW);

    delay(20);

  }

  // allumer LEDs 9 à 16

  for (int n = 0 ; n < 8 ; n++) {

    mcp.digitalWrite(n, HIGH);

    delay(20);

    mcp.digitalWrite(n, LOW);

    delay(20);

  }

}

 

Ce petit test m'a permis de trouver une mauvaise soudure sur la résistance R12 du module à MOSFETs. La soudure manuelle n'est pas fiable à 100%, surtout avec des composants CMS, d'où l'intérêt de tester la carte avant de l'utiliser dans un montage.

Voici le résultat :

6. Conclusion

Qu'il s'agisse de commander un écran LCD, des relais ou des MOSFETs, l'expander I2C est une solution que j'ai de plus en plus tendance à systématiser, car cela permet de réduire fortement le nombre de sorties à monopoliser sur le microcontrôleur, et aussi de minimiser la quantité de fils pour le câblage.

7. Liens utiles

D'autres articles à propos de relais :

Piloter un relais. Transistor unipolaire ou bipolaire ?

Modules à relais DIY

Relais Retardé sans Microcontrôleur

Télécommande de Relais par Infra-Rouge

Cordialement

Henri

8. Mises à jour

10/07/2021 : 2.1.2. Expander DIY

                      5.1. Essais du module MCP23008 DIY