View  Edit  Attributes  History  Attach  Print  Search

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


// --- Programme 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

// Programme 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 -------