


Composants utilisés
- 1 Module capteur de lumière ajustable à photo-résistance.
- Fils de branchement M/F (le module est livré avec 4 fils F/F Dupont)
- 1 Carte Arduino Uno reliée par câble USB au PC
- IDE Arduino 1.0.5 à télécharger ici http://arduino.cc/en/main/software
- Processing sur PC
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.

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 :

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).

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.

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