Module capteur de lumière à photo résistance et Processing

Utilisation de capteurs et composants électroniques avec Arduino.
Une fiche de tutoriel pour chaque.

Module capteur de lumière à photo résistance et Processing

Messagepar tiptop » Mar 24 Déc 2013 15:34

Module capteur de lumière à photo résistance avec Arduino, visualisation sous Processing

Image.Image.Image

Composants utilisés

Principe de fonctionnement
Ce module capteur de lumière à photo-résistance est prêt à l'emploi. Il est ajustable avec un potentiomètre de réglage, à dévisser pour réduire le seuil.
La résistance décroît avec la lumière ce qui augmente le courant qui circule. La relation n'est pas linéaire, on peut fixer des seuils avec Arduino ou faire un étalonnage.
Image

Applications
  • Mesures d'éclairement
  • Déclenchement automatique de lumière en cas d'obscurité
  • Economie d'énergie avec extinction quand la lumière solaire est suffisante pour éteindre les lampes.
  • Robot commandés par un faisceau de lumière.
  • Gestion d'éclairage de serre, hydroponique...

Caractéristiques
  • Le capteur possède un indicateur de signal de sortie digitale (dépassement de niveau).
  • La sensibilité numérique est ajustable pour modifier le seuil.
  • Puce LM 393, photo-résistance.
  • Parfait pour les applications de mesure et détection de lumière.
  • Montage facile du PCB (30 x 16 mm) avec un trou de fixation.


Câblage
Le module prêt à l'emploi comporte 4 broches
Module --> Arduino
  • A0 --> Sortie analogique (résistance variable) en tension ->pin A0 analogique
  • D0 --> Sortie digitale 0/5V ->pin 3 digitale
  • GND --> masse -> GND
  • Vcc --> Alimentation de 3 à 5V DC -> +5V

Programme
Chargez ce code dans la carte Arduino.
Code: Tout sélectionner
//************************************************//
//  Mesure analogique de luminosité avec
//  le module PhotoRésistance
//  TipTopboards.com
//  23 12 2013  demo_photoresistance
//************************************************
// Brancher +V -> 5V et GND
// Sortie analogique du capteur -> A0 arduino
// Sortie digitale du capteur -> A1 (avec seuil)

int PinLumiere=0;        //Broche Analogique de mesure d'éclairement
int PinSeuilLumiere=2;   //Broche Numérique mesure d'éclairement
int tension=0;     //Mesure de tension (valeur élevée si sombre)
int eclaire =0;    //0 ou 1 (0=éclairé>seuil, 1=ombre<seuil)

void setup(){ // Initialisation
    Serial.begin(9600);  //Connection série à 9600 baud
    pinMode(PinLumiere, INPUT);       //pin A0 en entrée analogique
    pinMode(PinSeuilLumiere, INPUT);  //pin 3 en entrée numérique
}

void loop() { //boucle principale
    tension = analogRead(PinLumiere); // Lit la tension analogique
    eclaire = digitalRead(PinSeuilLumiere);
    Serial.println(tension); // afficher la mesure
    //Serial.print("  ");   
    //Serial.println(eclaire);  //0 ou 1
    delay(20); //delai entre 2 mesures 20ms
}


Affichage dans le serial monitor :
Image

La sortie analogique délivre une tension élevée pour un faible éclairement, et une tension de sortie réduite pour un éclairement fort. Ceci permet de mesurer la luminosité ambiante.
Le potentiomètre bleu n'agit que sur le seuil de la sortie digitale. Celle ci passe à 1 si ombre, 0 si éclairé (logique négative).

Installation de Processing
Firmata est un protocole qui permet de communiquer avec le micro contrôleur depuis un logiciel sur un ordinateur hôte. Il est déjà incorporé dans le pack Arduino dans le dossier Exemples/Firmata.

Installez Processing (1.5.1) sur l'ordinateur hôte. Ce programme écrit en Java est openSource, il est multi-plateforme.
Il faut fermer le Serial Monitor pour utiliser Processing (c'est exclusif, l'un ou l'autre).

Image

Chargez ce code dans Processing.
Code: Tout sélectionner
//**********************************************************
//  Code source selon 
//  TipTopBoards.com  modifié 23 12 2013
//
//**********************************************************
// Cet oscilloscope Arduino lit les données envoyées par Serial.println(tension)
// Lia liaison série est réglée à 9600 bauds dans l'IDE Arduino

import processing.serial.*; // import de la librairie de communication serie

Serial maConnection; // Crée un objet de communication série
int tension=0; //  valeur de la tension lue sur le port Série

int fenetreTemps=12000; //  largeur de l'écran parcourue en 12 sec
int x=0;  //curseur au départ
int y=0;

void setup() {
    size(650, 400); // taille de l'écran de l'oescilloscope
    String NomDuPort = Serial.list()[0]; // Récupère la première interface serie trouvée
    println("connection a "+NomDuPort);
    maConnection = new Serial(this, NomDuPort, 9600); // création de la connexion série
    background(255); // Fond d'écran blanc
    smooth(); // Lisser les dessins
    strokeWeight(2); // Largeur de trait
    stroke(40); // Couleur du trait gris
    }
void draw() { //boucle de dessin principale
    //rien ne s'y passe, tout est géré dans la fonction serialEvent
}

void serialEvent (Serial maConnection) { // si des données arrivent par la connexion série
    String retour=maConnection.readStringUntil('\n'); // lit la donnée jusqu'à la fin de ligne
    if (retour != null) { //si le retour n'est pas vide
        retour = trim(retour); // enlever les espaces
        tension = int(retour); // converti le texte en nombre entier
    }
    //détermination du X actuel
    int oldx=x;
    x=(millis()%fenetreTemps)*width/fenetreTemps;
    if (oldx>x) {
        //reprise au debut de l'écran
        oldx=0;
        background(255); //fond d'écran blanc
    }
    //determination de la valeur de Y
    int oldy=y;
    y=int(map(tension, 0, 1023, 380, 20)); // mise à l'échelle de la tension pour entrer dans l'écran
    line(oldx, oldy, x, y); // dessine le trait
}

La carte Arduino va exporter (par serial) les mesures analogiques successives et Processing (sur le PC) trace alors le graphe de ces mesures, comme un oscilloscope.

Image

Remarques
La librairie serial utilise RX(0) et TX(1) qui ne doivent donc pas être utilisées sur la carte Arduino. La communication "série" passe physiquement par le port USB entre l'arduino et le PC.


Références
Processing pour Arduino http://playground.arduino.cc/Interfacing/Processing

Le site officiel de Processing http://processing.org

Attention, Serial ne fonctionne pas en 64 bits, et d'autre part la version 2.1 pour win32 buggue à cause de ReadStringUntil() donc j'ai utilisé la version 1.5.1 pour Win 32.
Télécharger http://processing.org/download/

Afficher un graphe (en anglais) http://arduino.cc/en/Tutorial/Graph
Affiche un graphe avec processing en mode oscilloscope (en français) http://www.mon-club-elec.fr/pmwiki_mon_ ... raphiquePC
oscilloscope http://fr.flossmanuals.net/arduino/ch023_oscilloscope
tiptopboards - admin
Avatar de l’utilisateur
tiptop
Administrateur du site
 
Messages: 88
Inscription: Mar 13 Aoû 2013 20:38
Localisation: 38

Retourner vers Capteurs et composants

Qui est en ligne

Utilisateurs parcourant ce forum: Aucun utilisateur enregistré et 4 invités