L’optocoupleur en fourche LTH301-7 est un dispositif de sécurité qui permet de détecter les défauts de tension et de courant dans les systèmes électriques. Il est conçu pour offrir une protection contre les surtensions et les courts-circuits, et est largement utilisé dans les applications industrielles et commerciales. Dans cet article, nous allons examiner en détail le test de l’optocoupleur en fourche LTH301-7 et discuter des méthodes et des outils nécessaires pour le tester correctement. Nous examinerons également les avantages et les inconvénients de l’utilisation de cet optocoupleur et comment il peut être utilisé pour améliorer la sécurité et la fiabilité des systèmes électriques.
Test de l’optocoupleur en fourche LTH301-7

Description
Voir la fiche : Optocoupleur en fourche (LITON LTH301-07)
Résultat
(cliquer pour agrandir)
- On constate que la sortie de l’optocoupleur donne les bonnes valeurs de tension pour les niveaux HAUT et BAS.
Le schéma utilisé pour le test
- Avec RLED = 270 Ohms et RPhotoT=4.7 Kohms
Le montage utilisé :
Le programme Arduino utilisé
A copier/coller directement dans l’éditeur Arduino
// par X. HINAULT – 01/2010
// — Que fait ce programme ? —
/* Affiche le résultat brut d’une conversion analogique numérique sur la fenêtre terminal du PC*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise la conversion analogique numérique 10bits sur les voies analogiques analog 0,
// — Circuit à réaliser —
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
// Broche Analog 0 (=broche 14) en entrée Analogique : connecter la sortie d’une résistance Variable 10K elle-même connectée entre 0 et 5V
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
// — constantes des broches —
const int Voie_0=0; //declaration constante de broche analogique
// — Déclaration des variables globales —
int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
// — Initialisation des fonctionnalités utilisées —
//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter au démarrage —
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
} // fin de la fonction setup()
// ********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
// — ici instructions à exécuter par le programme principal —
// acquisition conversion analogique-numerique (CAN) sur la voie analogique
mesure_brute=analogRead(Voie_0);
// affiche valeur numerique entière ou à virgule au format décimal
Serial.println(mesure_brute);
delay(10); // fixe une pause entre 2 mesures
// plus le délai est court, plus la trace est rapide
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// — Fin programme —
Le programme processing utilisé
A copier / coller dans l’éditeur Processing
// généré avec le générateur de code Processing
// X. HINAULT – Janvier 2011 – tous droits réservés
/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise une police texte
/////////////// ENTETE DECLARATIVE ////////////
// inclusion des librairies utilisées
import processing.serial.*; // importe la librairie série processing
// déclaration objets
// — port Série —
Serial myPort; // Création objet désignant le port série
// — police texte —
PFont fontA; // crée un objet de police texte
// déclaration variables globales
int xPos = 1; // variable abscisse – x
int xPos0=1; // variable mémorisation xPos n-1
float yPos=1; // variable yPos – ordonnée
float yPos0=1; // variable yPos n-1
int xTextPos=50; // variable position texte dans la fenêtre
int yTextPos=50;
/////////////// Fonction SETUP ////////////
void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage
// —- initialisation paramètres graphiques utilisés
colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
fill(0,0,255); // couleur remplissage RGB
stroke (0,255,0); // couleur pourtour RGB
strokeWeight(1); // largeur du trait en pixels
rectMode(CORNER); // origine rectangle coin sup gauche
// — initialisation fenêtre de base —
//size(200, 200); // ouvre une fenêtre xpixels x ypixels
size(int(screen.width*0.8), int(screen.height*0.8));
// 90% de l’écran par défaut – régler au besoin –
// viser taille maxi en hauteur – taille fenêtre (x,y)
background(0,0,0); // fond fenetre en noir
// — initialisation des fonctionnalités utilisées —
//————- initialisation de la police texte – à mettre avant série —-
fontA = loadFont(« ArialMT-20.vlw »); // charge le fichier police dans l’objet police texte
// ce fichier doit être présent dans un rép <data> dans le répertoire du programme
// pour générer un fichier de police à partir des polices système aller dans Tools > create Fonts
// voir également http://processing.org/learning/text/
textFont(fontA, 20); // Initialise la police et sa taille (en pixels)
//————- initialisation port série —-
println(Serial.list()); // affiche dans la console la liste des ports séries
//myPort = new Serial(this, Serial.list()[1], 115200); // Initialise une nouvelle instance du port Série
myPort = new Serial(this, « /dev/ttyUSB0 », 115200); // Initialise une nouvelle instance du port Série
myPort.bufferUntil(‘\n‘); // attendre arrivée d’un saut de ligne pour générer évènement série
//——- tracé initial ———
traceInitial();
} // fin fonction Setup
/////////////// Fonction Draw ////////////
void draw() { // fonction exécutée en boucle
// while(true); // stoppe boucle draw
} // fin de la fonction draw()
/////////////// Autres Fonctions ////////////
//————- Fonction de gestion des évènements série —-
void serialEvent (Serial myPort) { // fonction appelée lors de la survenue d’un évènement série
// ******** Gestion de la valeur reçue sur le port série : **********
String inString = myPort.readStringUntil(‘\n‘); // chaine stockant la chaîne reçue sur le port Série
// saut de ligne en marque de fin
if (inString != null) { // si la chaine recue n’est pas vide
inString = trim(inString); // enlève espace blancs de la chaine recue
int inByte_brut=int(inString); // conversion valeur reçue en valeur numérique entiere
float inByte = float(inString); // conversion valeur reçue en valeur numérique décimale
// ré-échelonne la valeur pour affichage
inByte = map(inByte, 0, 1023, 0, height);
yPos=inByte; // l’ordonnée est la valeur reçue par le port série
//********** affichage numérique de la valeur reçue et autres calculs *****
//—- calcul de la tension à afficher ——–
float tension=float(inByte_brut);
tension=tension*5000;
tension=tension/1023;
// dessin d’un rectangle sous le texte avant affichage pour effacer texte précédent
fill(0,0,0); // couleur de remplissage idem fond
stroke(255,0,0); // fixe la couleur utilisée pour le tracé en RVB
rect(40, 20, 200, 50);
// Use fill() to change the value or color of the text
fill(255,0,0);
text( » « , xTextPos, yTextPos); //efface la valeur précédente
//text(inByte_brut, xTextPos, yTextPos);
text(tension+ » mV », xTextPos, yTextPos);
//*********** gestion du graphique *********
// trace la ligne
stroke(0,255,255); // fixe la couleur utilisée pour le tracé en RVB
strokeWeight(3); // largeur du trait en pixels
line (xPos0,height–yPos0,xPos,height–yPos); // trace une ligne en tenant compte valeur reçue
xPos0=xPos; // mémorisation xPos n-1
yPos0=yPos; // mémorisation xPos n-1
// à la fin de l’écran revient au début
if (xPos >= width) {
xPos = 0;
xPos0=0; // pour retour de la trace sans ligne
background(0,0,0); // couleur du fond
//——- tracé initial ———
traceInitial();
} // fin RAZ graphique
else {
// incrémente la position horizontale (abscisse)
xPos++;
}
} // fin condition chaine recue pas vide
} // fin de la fonction de gestion des évènements Série
void traceInitial() {
fill(0,255,0); // couleur remplissage RGB
stroke (0,255,0); // couleur pourtour RGB
strokeWeight(1); // largeur du trait en pixels
for (int i=0; i<5; i++) {
line (0,height–((height/5)*i), width–1,height–((height/5)*i));
text(i+« V », 5, height–((height/5)*i)+25);
}
stroke (255,255,0); // couleur pourtour RGB
strokeWeight(3); // largeur du trait en pixels
fill(255,255,0); // couleur remplissage RGB
// — ligne niveau logique bas = 0.3 x Vcc pour carte Arduino (ATmega328) —-
text(« Niveau BAS », 5, (height–(0.3*height)–5));
line (0,(height–(0.3*height)), width–1,(height–(0.3*height)));
// — ligne niveau logique haut = 0.6 x Vcc pour carte Arduino (ATmega328) —
text(« Niveau HAUT », 5, (height–(0.6*height)–5));
line (0,(height–(0.6*height)), width–1,(height–(0.6*height)));
}
// —– mémo fonctions processing ——-
Articles Liés
- Javascript : Graphique Dygraphs simple
Le Javascript est un langage de programmation très populaire et puissant qui permet aux développeurs…
- Javascript : Afficher 6 widgets graphiques fournis par une librairie graphique externe.
Le Javascript est un langage de programmation très populaire qui permet aux développeurs de créer…
- Javascript : Graphique Dygraphs : afficher date à partir unixtime
Le langage de programmation Javascript est très populaire et est utilisé pour créer des applications…