Optocoupleur : fonctionnement, PC817 et 4N35 avec Arduino

Un optocoupleur (aussi appelé opto-isolateur ou photocoupleur) est un petit composant qui transmet un signal entre deux circuits uniquement grâce à la lumière, sans aucune liaison électrique entre eux. À l'intérieur se trouvent une LED infrarouge et un phototransistor placé face à elle : quand le circuit d'un côté allume la LED, le transistor de l'autre côté conduit. Comme il n'y a pas un seul fil entre les deux côtés, les pics de tension et les parasites ne peuvent pas atteindre ton microcontrôleur quand tu relies à ton Arduino un capteur industriel 24 V, le circuit 12 V d'une voiture ou un driver de moteur.

Dans cet article, tu vas apprendre pas à pas ce qu'il y a dans un optocoupleur, pourquoi l'isolation galvanique est importante, le brochage et les caractéristiques des deux modèles les plus courants, le PC817 et le 4N35, la notion de CTR et le calcul des résistances. Ensuite, tu verras comment isoler une sortie d'Arduino, lire des signaux 12/24 V en sécurité, l'utiliser avec l'ESP32 et le Raspberry Pi Pico, les règles de sécurité pour détecter le secteur (H11AA1), l'optocoupleur des modules relais et la commande d'un triac avec le MOC3021.

Qu'est-ce qu'un optocoupleur et comment fonctionne-t-il ?

Dans le boîtier d'un optocoupleur, deux puces se font face. Côté entrée, une LED infrarouge fonctionne avec du courant comme une LED ordinaire. Côté sortie, un phototransistor possède une base sensible à la lumière ; au lieu d'injecter du courant dans la base, on l'éclaire. Entre les deux puces se trouve une couche de plastique transparente mais isolante électriquement. Cette couche est conçue pour résister à des milliers de volts.

1. Le circuit côté entrée fait passer quelques milliampères dans la LED à travers une résistance.
2. La LED émet une lumière infrarouge ; cette lumière traverse la couche isolante et tombe sur le phototransistor.
3. La lumière agit comme le courant de base du phototransistor et laisse passer le courant entre collecteur et émetteur ; le transistor se ferme comme un interrupteur.
4. Quand la LED s'éteint, la lumière disparaît, le transistor se bloque à nouveau et le circuit de sortie s'ouvre. Le signal est passé de l'autre côté sans fil, uniquement par la lumière.

Selon ce qui se trouve côté sortie, il existe plusieurs types d'optocoupleurs. Les projets amateurs utilisent surtout des modèles à phototransistor, mais détecter un signal alternatif, déclencher un triac ou isoler une ligne de données rapide demande des types spéciaux :

Pourquoi l'isolation galvanique est-elle nécessaire ?

L'isolation galvanique signifie qu'il n'existe aucun chemin conducteur direct entre deux circuits : pas de GND commun, pas de fil partagé, l'énergie et l'information passent par une autre voie (lumière, champ magnétique). Les broches de l'Arduino supportent au maximum 5 V (3,3 V sur l'ESP32 et le Pico). Les 24 V d'un capteur industriel, les brèves pointes de centaines de volts qu'un moteur produit en commutant ou les parasites induits dans de longs câbles peuvent atteindre directement le microcontrôleur par un GND commun. L'optocoupleur coupe physiquement ce chemin.

• Protection : même en cas de panne côté haute tension, les dégâts restent dans l'optocoupleur ; l'Arduino, le port USB de ton ordinateur et toi restez en sécurité.
• Parasites et boucles de masse : moteurs, relais et longs câbles créent du bruit sur la ligne GND. Quand les masses sont séparées, ce bruit ne se mélange pas au signal ; nous détaillons la masse commune dans l'article GND et masse commune.
• Niveaux de tension différents : comme le transistor de sortie est alimenté de l'extérieur, un signal 24 V devient facilement 3,3 V et un signal 5 V devient 12 V. L'optocoupleur est aussi un convertisseur de niveau lent mais robuste.
• Normes de sécurité : dans les appareils reliés au secteur, le côté utilisateur doit être isolé du secteur ; des composants comme le PC817 passent un test d'isolation de 5000 V eff.

Brochage et caractéristiques du PC817 et du 4N35

Sur le PC817, la broche 1 est repérée par un point ; la lettre A, B, C ou D qui suit "PC817" sur le boîtier indique la classe de CTR. Des composants comme l'EL817, le LTV817 et le KP1010 sont des équivalents compatibles broche à broche. Le 4N35 a six pattes, sa base est donc accessible ; on la laisse généralement libre, et dans un environnement très parasité une résistance de forte valeur (par ex. 1 MΩ) entre base et émetteur accélère le blocage.

Qu'est-ce que le CTR et comment calculer les résistances ?

Le CTR (Current Transfer Ratio, rapport de transfert de courant) est le rapport entre le courant de collecteur que le transistor de sortie peut laisser passer et le courant de la LED : CTR = IC / IF × 100 %. Par exemple, avec un optocoupleur dont le CTR vaut 100 %, si tu fais passer 5 mA dans la LED, tu peux tirer au maximum environ 5 mA en sortie. Le CTR varie avec la température, baisse au fil des années avec le vieillissement de la LED et diffère beaucoup même entre composants du même modèle. C'est pourquoi on dimensionne toujours avec la valeur minimale de la fiche technique.

Résistance de la LED : le côté entrée se calcule exactement comme une LED : R = (Valim − VF) / IF. Pour faire passer 10 mA depuis la broche 5 V d'un Arduino Uno, on obtient (5 − 1,2) / 0,010 = 380 Ω ; une 330 Ω standard donne environ 11,5 mA et une 390 Ω environ 9,7 mA. Sur l'ESP32, (3,3 − 1,2) / 0,010 = 210 Ω, donc tu prends 220 Ω. Les broches du Raspberry Pi Pico sont réglées par défaut sur une intensité de sortie de 4 mA ; ici environ 4,5 mA avec 470 Ω suffisent. Si tu ne veux pas faire le calcul à la main, utilise l'outil Résistance de LED.

Résistance de sortie (pull-up) : pour que le transistor conduise complètement (se sature), le courant demandé par la pull-up doit être inférieur à celui que permet le CTR. Une pull-up de 10 kΩ vers 5 V ne demande que 0,5 mA. Avec un PC817 sans lettre, le pire CTR est de 50 %, donc 1 mA dans la LED suffirait pour 0,5 mA ; en lui donnant 5 à 10 mA, tu gardes au moins cinq fois de marge. La pull-up interne de l'Arduino (environ 20–50 kΩ) convient aussi parfaitement. Une pull-up plus petite rend le signal plus rapide mais demande plus de courant ; une plus grande demande moins de courant mais ralentit le blocage du transistor.

Tableau de câblage : Arduino Uno, ESP32 et Raspberry Pi Pico

Isoler une sortie d'Arduino

Dans ce montage, l'Arduino allume la LED de l'optocoupleur et le transistor de sortie court-circuite l'entrée d'un autre circuit comme un interrupteur. Tu peux ainsi commander en toute sécurité l'entrée de déclenchement d'un appareil 12 V, l'entrée de télécommande d'un appareil photo, une entrée d'automate ou un autre microcontrôleur fonctionnant sous une autre tension. Comme le transistor de sortie est limité à 35 V et 50 mA, il ne peut pas piloter directement une bobine de relais, un moteur ou un ruban LED ; pour ce genre de charge, tu utilises un transistor ou un MOSFET de l'autre côté.

1// PC817 ile yalıtılmış çıkış / Isolated output with a PC817
2// D9 -> 330 ohm -> PC817 pin 1 (anot / anode), pin 2 (katot / cathode) -> Arduino GND
3// Pin 4 ve 3 diğer devrenin girişini kısa devre eder (kuru kontak gibi)
4// Pins 4 and 3 short the other circuit's input (like a dry contact)
5const int OPTO_LED_PIN = 9;
6const unsigned long ON_MS = 2000;
7const unsigned long OFF_MS = 3000;
8
9bool isOn = false;
10unsigned long lastSwitch = 0;
11
12void setup() {
13  pinMode(OPTO_LED_PIN, OUTPUT);
14  digitalWrite(OPTO_LED_PIN, LOW);
15}
16
17void loop() {
18  unsigned long waitTime = isOn ? ON_MS : OFF_MS;
19  if (millis() - lastSwitch >= waitTime) {
20    lastSwitch = millis();
21    isOn = !isOn;
22    digitalWrite(OPTO_LED_PIN, isOn ? HIGH : LOW);   // HIGH: optokuplör iletir / HIGH: optocoupler conducts
23  }
24}

Côté sortie, relie le collecteur (broche 4) au côté positif ou à l'entrée de l'autre circuit et l'émetteur (broche 3) au GND de ce circuit ; si la polarité est inversée, le transistor ne conduit pas. Comme un PC817 met de quelques à quelques dizaines de microsecondes pour s'allumer et s'éteindre, un signal PWM qui le traverse commence à se déformer au-delà de quelques kHz. Pour les signaux rapides (UART, MIDI, PWM haute fréquence), on préfère des optocoupleurs rapides comme le 6N137 ou des circuits isolateurs numériques.

Lire un signal 12/24 V en toute sécurité

Tu ne peux pas relier directement à une broche d'Arduino les signaux de capteurs inductifs industriels, de sorties d'automate, de contacts de porte, du contact d'une voiture ou d'un bouton de sonnette 12 V. La solution consiste à faire passer le signal dans la LED de l'optocoupleur : tu mets une résistance de 4,7 kΩ en série avec la LED pour 24 V et de 2,2 kΩ pour 12 V, et le transistor de sortie fonctionne avec la pull-up interne de l'Arduino. Quand la tension est présente, la LED s'allume, le transistor conduit et la broche de l'Arduino lit LOW. La logique est donc inversée ; tu en tiens compte dans le code.

1. Relie le plus de la source 24 V, à travers une résistance de 4,7 kΩ, à la broche 1 (anode) du PC817.
2. Relie le moins de la source du signal (GND 24 V) à la broche 2 (cathode). Ne relie pas ce GND à l'Arduino.
3. Si tu veux, ajoute une diode 1N4148 en inverse entre les broches 1 et 2 (cathode sur la broche 1) ; elle protège contre l'inversion de polarité.
4. Relie la broche 4 (collecteur) du PC817 à la broche D2 de l'Arduino et la broche 3 (émetteur) au GND de l'Arduino.
5. Téléverse le code ci-dessous et ouvre le Moniteur série à 9600 bauds. Quand tu appliques 24 V, tu dois voir "24V VAR / present".

1// PC817 ile 12/24 V sinyal okuma / Reading a 12/24 V signal with a PC817
2// PC817 pin 4 (kolektör / collector) -> D2, pin 3 (emetör / emitter) -> Arduino GND
3const int OPTO_PIN = 2;
4const unsigned long DEBOUNCE_MS = 20;    // kontak sıçramasına karşı / against contact bounce
5
6int lastReading = HIGH;
7int stableState = HIGH;
8unsigned long lastChange = 0;
9unsigned long pulseCount = 0;
10
11void setup() {
12  Serial.begin(9600);
13  pinMode(OPTO_PIN, INPUT_PULLUP);       // dahili pull-up yeterli / internal pull-up is enough
14}
15
16void loop() {
17  int reading = digitalRead(OPTO_PIN);
18  if (reading != lastReading) {          // değişim var, zamanı başlat / change seen, start the timer
19    lastChange = millis();
20    lastReading = reading;
21  }
22  if (millis() - lastChange > DEBOUNCE_MS && reading != stableState) {
23    stableState = reading;
24    // Mantık ters: 24 V varsa LED yanar, transistör iletir, pin LOW olur
25    // Inverted logic: with 24 V present the LED is on, the transistor conducts, the pin reads LOW
26    if (stableState == LOW) {
27      pulseCount++;
28      Serial.print("24V VAR / present, sayac / count: ");
29      Serial.println(pulseCount);
30    } else {
31      Serial.println("24V YOK / absent");
32    }
33  }
34}

Le code contient un anti-rebond simple qui n'accepte que les lectures restées stables pendant 20 ms ; c'est indispensable pour les signaux venant de contacts mécaniques ou de relais. Comme nous lisons avec millis() au lieu de delay(), l'Arduino peut faire autre chose pendant ce temps. Dans le circuit électrique d'une voiture, la ligne 12 V monte à 14,4 V moteur tournant et de brèves pointes élevées apparaissent ; augmenter la résistance à 3,3 kΩ et ajouter une diode TVS à l'entrée est alors une bonne précaution.

L'optocoupleur avec l'ESP32 et le Raspberry Pi Pico

Comme l'ESP32 et le Pico fonctionnent en 3,3 V, il ne faut même pas les relier directement à des signaux 5 V. Ce qui est pratique avec l'optocoupleur, c'est que le transistor de sortie est à collecteur ouvert : la tension de sortie ne dépend que de la tension sur laquelle est branchée la pull-up. Avec la pull-up interne, la sortie reste automatiquement en 3,3 V ; même avec 24 V côté entrée, l'ESP32 ne reçoit jamais plus de 3,3 V. Le code ESP32 ci-dessous compte par interruption les impulsions d'un capteur inductif ou d'un débitmètre 24 V :

1// ESP32: 24 V endüstriyel sensörden darbe sayma / counting pulses from a 24 V industrial sensor
2// PC817 pin 4 -> GPIO 27, pin 3 -> ESP32 GND
3const int OPTO_PIN = 27;
4
5volatile unsigned long pulseCount = 0;
6volatile unsigned long lastPulseUs = 0;
7
8void IRAM_ATTR onPulse() {
9  unsigned long now = micros();
10  if (now - lastPulseUs > 2000) {        // 2 ms'den kısa parazitleri yok say / ignore glitches shorter than 2 ms
11    pulseCount++;
12    lastPulseUs = now;
13  }
14}
15
16void setup() {
17  Serial.begin(115200);
18  pinMode(OPTO_PIN, INPUT_PULLUP);
19  attachInterrupt(digitalPinToInterrupt(OPTO_PIN), onPulse, FALLING);   // 24 V gelince pin düşer / pin falls when 24 V arrives
20}
21
22void loop() {
23  static unsigned long lastPrint = 0;
24  if (millis() - lastPrint >= 1000) {
25    lastPrint = millis();
26    noInterrupts();
27    unsigned long count = pulseCount;
28    pulseCount = 0;
29    interrupts();
30    Serial.printf("Saniyedeki darbe / Pulses per second: %lu\n", count);
31  }
32}

Le mot-clé IRAM_ATTR devant la fonction d'interruption place le code en mémoire rapide ; il est recommandé pour les fonctions d'interruption sur l'ESP32. Le filtre de 2 ms élimine les fausses impulsions dues au blocage lent de l'optocoupleur ou aux parasites du câble. Pour en savoir plus sur les interruptions, jette un œil à l'article Les interruptions sur Arduino. Sur le Raspberry Pi Pico, tu fais la même chose en MicroPython ainsi ; tout en lisant l'entrée, cet exemple envoie aussi un signal isolé de l'autre côté avec un deuxième PC817 :

1# Raspberry Pi Pico: PC817 ile yalıtılmış giriş / isolated input with a PC817
2# PC817 pin 4 -> GP14, pin 3 -> Pico GND, LED sürme / LED drive: GP15 -> 470 ohm -> pin 1
3from machine import Pin
4import time
5
6opto_in = Pin(14, Pin.IN, Pin.PULL_UP)     # dahili pull-up / internal pull-up
7opto_out = Pin(15, Pin.OUT)                # ikinci PC817'nin LED'i / LED of a second PC817
8
9last_state = opto_in.value()
10while True:
11    state = opto_in.value()
12    if state != last_state:
13        time.sleep_ms(20)                  # sıçramayı bekle / wait out the bounce
14        state = opto_in.value()
15        if state != last_state:
16            last_state = state
17            if state == 0:                 # ters mantık: 0 = gerilim var / inverted: 0 = voltage present
18                print("24V VAR / present")
19                opto_out.value(1)          # karşı tarafa yalıtılmış sinyal / isolated signal to the other side
20            else:
21                print("24V YOK / absent")
22                opto_out.value(0)
23    time.sleep_ms(5)

Détecter le 230 V : le H11AA1 et la sécurité

Pour savoir si une prise ou une ligne d'éclairage est sous tension, ou pour repérer les passages par zéro du secteur, on utilise des optocoupleurs à entrée alternative comme le H11AA1. Il contient deux LED montées tête-bêche ; il produit donc de la lumière sur les deux alternances du courant alternatif et ne souffre pas de tension inverse. Pour 230 V eff, on place deux résistances de 47 kΩ en série avec l'entrée : environ 2,4 mA eff (3,5 mA en crête) traversent les 94 kΩ au total et chaque résistance dissipe environ 0,28 W. C'est pourquoi on choisit des résistances d'au moins 0,5 W, idéalement 1 W ; utiliser deux résistances répartit aussi la tension de moitié sur chacune. Côté sortie, avec une pull-up de 10 kΩ vers 5 V, le transistor conduit presque tout le temps quand la tension est présente ; ce n'est qu'au voisinage des passages par zéro, quand les LED s'éteignent, qu'une brève impulsion HIGH apparaît. Sur un secteur 50 Hz, tu verras environ 100 impulsions par seconde.

1// H11AA1 ile şebeke gerilimi var mı? / Is mains voltage present? (H11AA1)
2// H11AA1 pin 5 (kolektör / collector) -> D2, pin 4 (emetör / emitter) -> GND, 10k pull-up -> 5V
3const int AC_PIN = 2;
4const unsigned long TIMEOUT_MS = 40;     // 50 Hz'de 2 tam periyot / 2 full cycles at 50 Hz
5
6volatile unsigned long pulses = 0;
7unsigned long lastLowSeen = 0;
8unsigned long lastReport = 0;
9
10void onZeroCross() {
11  pulses++;                              // her sıfır geçişinde bir darbe / one pulse per zero crossing
12}
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(AC_PIN, INPUT);                // harici 10k pull-up kullanılıyor / external 10k pull-up in use
17  attachInterrupt(digitalPinToInterrupt(AC_PIN), onZeroCross, RISING);
18}
19
20void loop() {
21  if (digitalRead(AC_PIN) == LOW) {
22    lastLowSeen = millis();              // gerilim varken çıkış çoğunlukla LOW / output is mostly LOW while voltage is present
23  }
24  bool mainsOn = (millis() - lastLowSeen) < TIMEOUT_MS;
25
26  if (millis() - lastReport >= 1000) {   // saniyede bir rapor / report once per second
27    lastReport = millis();
28    noInterrupts();
29    unsigned long count = pulses;
30    pulses = 0;
31    interrupts();
32    Serial.print(mainsOn ? "Sebeke VAR / Mains ON" : "Sebeke YOK / Mains OFF");
33    Serial.print("  sifir gecisi / zero crossings: ");
34    Serial.print(count);                 // 50 Hz'de yaklaşık 100 / about 100 at 50 Hz
35    Serial.print("  frekans / frequency: ");
36    Serial.print(count / 2);
37    Serial.println(" Hz");
38  }
39}

Le code donne deux informations : si la sortie est passée au moins une fois à LOW pendant les 40 dernières ms, le secteur est présent ; et la moitié des impulsions comptées par l'interruption donne la fréquence du secteur. Points à surveiller sur les modules tout faits comme sur ta propre carte : laisse au moins 6 à 8 mm d'écart (ligne de fuite) entre les pistes secteur et le côté basse tension, mets un fusible sur l'entrée secteur, ne fais jamais passer de piste entre les deux côtés de l'optocoupleur et utilise le montage dans un boîtier fermé.

L'optocoupleur des modules relais et le cavalier JD-VCC

La plupart des modules relais à 1, 2, 4 et 8 canaux du commerce ont un PC817 sur l'entrée de chaque canal. Le courant de la broche VCC traverse une résistance et une LED témoin jusqu'à la LED de l'optocoupleur ; quand la broche IN passe à LOW, le circuit se ferme et le relais colle. C'est pourquoi ces modules fonctionnent généralement actifs à l'état bas. Cependant, à la sortie d'usine, le cavalier JD-VCC est en place et la bobine du relais est alimentée par les mêmes VCC et GND : l'optocoupleur est là, mais il n'y a pas d'isolation. Tu trouveras les bases des modules relais dans l'article Qu'est-ce qu'un module relais ?.

Remarque : commander un triac avec le MOC3021

Si tu veux un interrupteur alternatif silencieux et sans étincelle à la place d'un relais, on utilise un triac (par ex. BT136) et un optocoupleur à sortie triac pour le commander. Le MOC3021 est à phase aléatoire : il déclenche le triac au moment où la LED s'allume, ce qui convient, avec un détecteur de passage par zéro, à la réalisation d'un variateur. Les MOC3041 et MOC3063 intègrent un circuit de passage par zéro ; ils ne déclenchent que lorsque la tension passe par zéro, génèrent moins de parasites en marche/arrêt, mais ne permettent pas de faire varier la puissance. La LED du MOC3021 peut demander jusqu'à 15 mA pour déclencher ; en 5 V, 220 Ω (environ 17 mA) est une valeur adaptée, alors que 330 Ω peut être insuffisant pour certains exemplaires. Comme dans les fiches techniques, on place une résistance d'environ 360 Ω entre la gâchette du triac et le MOC3021, et pour les charges inductives comme les moteurs on ajoute un circuit RC (snubber) aux bornes du triac. Les modules SSR (relais statiques) tout faits contiennent exactement cette structure.

Idées de projets avec un optocoupleur

• Lecteur de capteur industriel : compte des pièces sur un convoyeur avec un capteur de proximité inductif 24 V et affiche le total sur un écran LCD.
• Détecteur de contact de voiture : réveille l'ESP32 quand le contact est mis et démarre la caméra embarquée ou un enregistreur.
• Alarme de coupure de courant : avec un module de détection AC tout fait, fais sonner un buzzer ou envoie une notification sur ton téléphone quand le secteur est coupé.
• Détecteur de sonnette : lis la ligne 12 V de la sonnette existante de façon isolée et envoie une notification quand elle sonne.
• Carte relais isolée : commande une lampe 230 V avec un module relais dont tu as retiré le cavalier JD-VCC et que tu alimentes par une source séparée.
• Entrée MIDI : lis sur l'Arduino les notes MIDI d'un instrument électronique avec un 6N138.

Erreurs fréquentes et solutions

L'optocoupleur est le moyen le moins cher de sortir un projet Arduino du bureau et de le faire dialoguer en sécurité avec les signaux 12 V, 24 V et 230 V du monde réel : un composant à quelques centimes sépare ta carte et ton ordinateur de la haute tension. Dans l'application BlueGrays, tu trouveras les projets de commande d'une ampoule 230 V par relais, d'éclairage intelligent et d'arrosage, pas à pas avec schémas de câblage et code.