problème capteur lumière

Bonjour,
Je suis "novice" dans l'Arduino et je cherche à faire un capteur de luminosité avec indicateur par LED...
tout se passe bien quand la lumière est allumé, la LED 10 s'allume, mais quand j'éteins la lumière, toutes les LED s'allumes puis s'éteignent une demi-seconde plus tard.
Elles devraient normalement toutes s'allumer, donc petit problème...
Voici le code si vous pouvez m'aider

const int led1 = 2; // la LED est liée à la broche digitale 2
const int led2 = 3; // la LED est liée à la broche digitale 3
const int led3 = 4; // la LED est liée à la broche digitale 4
const int led4 = 5; // la LED est liée à la broche digitale 5
const int led5 = 6; // la LED est liée à la broche digitale 6
const int led6 = 7; // la LED est liée à la broche digitale 7
const int led7 = 8; // la LED est liée à la broche digitale 8
const int led8 = 9; // la LED est liée à la broche digitale 9
const int led9 = 10; // la LED est liée à la broche digitale 10
const int led10 = 11; // la LED est liée à la broche digitale 11


void setup() {
  pinMode(led1, OUTPUT);  // configurer la broche comme sortie
  pinMode(led2, OUTPUT);
    pinMode(led3, OUTPUT);
      pinMode(led4, OUTPUT);
        pinMode(led5, OUTPUT);
          pinMode(led6, OUTPUT);
            pinMode(led7, OUTPUT);
              pinMode(led8, OUTPUT);
                pinMode(led9, OUTPUT);
                  pinMode(led10, OUTPUT);                 
}
void loop() {
  int value = analogRead(A0); // la LDR est liée à la broche analogique 0

// LED 1

if (value <= 102)
{
digitalWrite ( led1, HIGH ) ;
}
else {
digitalWrite ( led1, LOW ) ;
}


// LED 2
if (value <= 204)
{
digitalWrite ( led2, HIGH ) ;
}
else {
digitalWrite ( led2, LOW ) ;
}


// LED 3

if (value <= 306)
{
digitalWrite ( led3, HIGH ) ;
}
else {
digitalWrite ( led3, LOW ) ;
}

// led 4


if (value <= 308)
{
digitalWrite ( led4, HIGH ) ;
}
else {
digitalWrite ( led4, LOW ) ;
}


// LËD 5


if (value <= 410)
{
digitalWrite ( led5, HIGH ) ;
}
else {
digitalWrite ( led5, LOW ) ;
}


//LED 6


if (value <= 512)
{
digitalWrite ( led6, HIGH ) ;
}
else {
digitalWrite ( led6, LOW ) ;
}

// LED 7


if (value <= 614)
{
digitalWrite ( led7, HIGH ) ;
}
else {
digitalWrite ( led7, LOW ) ;
}


// LED 8


if (value <= 716)
{
digitalWrite ( led8, HIGH ) ;
}
else {
digitalWrite ( led8, LOW ) ;
}


// LED 9


if (value <= 818)
{
digitalWrite ( led9, HIGH ) ;
}
else {
digitalWrite ( led9, LOW ) ;
}


// LED 10


if (value <= 1023)
{
digitalWrite ( led10, HIGH ) ;
}
else {
digitalWrite ( led10, LOW ) ;
}

   
        

}

merci d'avance

carlitototo

J'ai un schéma fritzing mais je ne sait pas comment l'importer :confused:

la carte c'est une carte compatible arduino ( kuman uno )
la photorésistance... c'est une photorésistance
il y a 10 leds connectées en sortie à une résistance 220 Ohm
et une résistance 10 K Ohm pour faire un pont diviseur de tension ( je crois que ça s'appelle comme ça )

Merci

Boujour les copains,
Mon petit grain de sel :
Tu déclares tes constantes par des int.
Hors tes valeurs restent toutes < 255.
Il serait plus logique de déclarer des byte, reflexe d'optimisation des données.
Ensuite, à un indice qui varie, tu fais N fois une action identique. Il serait plus judicieux d'inclure toutes ces actions dans une boucle du genre :

void setup() {for (byte I = 2; I < 12; I++) pinMode(I, OUTPUT);}

Je n'ai pas le temps de tester ce code, mais à mon avis il doit remplacer toutes tes lignes.
Avoue que c'est plus court. Comme l'indice I n'est plus très parlant, juste avant tu précises en remarque ce qu'il représente, Ou au lieu de le nommer I tu utilises LEDnum par exemple.

Ensuite, dans ta boucle de base tu enchaînes avec une multitude de traitement qui font des traitements similaires, mais sélectionnés en fonctions de valeurs distinctes.
Ce type de traitement relèverait d'un switch / case.

ceci dit, tu peux déjà simplifier en imposant LOW dans une boucle et en faisant une suite de if. C'est loin d'être optimisé, mais c'est déjà plus compact il me semble.

void loop() {
int value = analogRead(A0); // La LDR est liée à la broche analogique 0

for (byte I = 2; I < 12; I++) digitalWrite(I, LOW);

if (value <= 102) digitalWrite(2, HIGH ) ;
if (value <= 204) digitalWrite(3, HIGH ) ;
if (value <= 306) digitalWrite(4, HIGH ) ;
if (value <= 308) digitalWrite(5, HIGH ) ;
if (value <= 410) digitalWrite(6, HIGH ) ;
if (value <= 614) digitalWrite(7, HIGH ) ;
if (value <= 716) digitalWrite(8, HIGH ) ;
if (value <= 818) digitalWrite(9, HIGH ) ;
if (value <= 1023) digitalWrite(10, HIGH ) ; }

Pour le switch / case il faudrait remplacer la batterie de tests par une translation du genre :

Niveau = map(analogRead(14),0,1023,2,11);

Cette instruction commence par lire la valeur sur ton entrée analogique A0, puis place dans la variable Niveau une valeur comprise entre 2 et 11 lorsque la conversion numérique évolue entre 0 et 1023. Niveau est déclarée comme byte au préalable pour que ça fonctionne.
Seule faille, il faut que dans ton application les seuils soient régulièrement répartis, car map() présente un comportement de "translation" linéaire.

Bref, chaque fois que tu choisiras au mieux tes types de données et les structures de contrôle de ton programme, ce dernier gagnera en lisibilité et en efficacité.

Tu déclares tes constantes par des int.
Hors tes valeurs restent toutes < 255.
Il serait plus logique de déclarer des byte, reflexe d'optimisation des données.

En règle générale le conseil est (presque) bon.

Dans le cas particulier on s'en fiche car le compilateur voyant qu'il a affaire à des constantes fera automatiquement l'optimisation.
Mais c'est parfaitement vrai qu'il ne faut pas se décharger sur un compilateur dont on ne maîtrise pas complètement le fonctionnement.

(presque) bon :
Le type byte n'est pas normalisé : il est défini dans l'IDE Wiring/arduino. Rien ne prouve qu'avec un autre framework le code fonctionnera.

Par contre ce qui est normalisé c'est le type int8_t et uint8_t (8, 16, 32)
8 pour 8bits = 1 octet
16 pour 2 octets etc .......

Ces définitions ont été proposée car la définition d'un int dépend du compilateur : il peut faire 1, 2, 4, ou plus, octets.
En utilisant la définition (u)intX_t ce n'est plus le compilateur qui impose sa loi c'est le programmeur et le code est plus portable.

Je comprend rien à tout ça ... mais ton code marche nulentout !

Bon, il y a quelques LEDs déffectueuses... mais je les remplaces.

Je me demande pourquoi ton code marche mais merci...

La seule façon de comprendre pourquoi un programme fonctionne, c'est d'observer chaque instruction, d'aller voir leur syntaxe. C'est ainsi que l'on apprend petit à petit un langage.
Haaaa, la portabilité ... tout un programme.
Oui, je connais les écritures du genre int8_t, mais dans la mesure où je suppose que le système d'exploitation sera l'IDE, ce qui me semble être le contexte, personnellement je préfère des mots comme byte, int, float que je trouve plus "lisibles".
Naturellement, c'est un point de vue tout très personnel.

Content de savoir que le programme fonctionne, mais à mon sens c'est presque accessoire. Le plus utile je crois, serait maintenant que tu cherches à comprendre chaque instruction, ainsi tu augmenteras ton "savoir faire" et surtout ton autonomie.
Amicalement : Nulentout.

PUB : Si tu vas sur :
http://forum.arduino.cc/index.php?topic=246614.0
Tu y trouveras un petit manuel à imprimer qui résume la syntaxe des instructions d'Arduino. Ce sera déjà une base de départ pour comprendre les écritures des programmes mis en ligne. Ce n'est jamais évident, alors avoir une référence à portée de la main est souvent bien utile.