Besoin aide création compteur

bonjour a toute est a tous,
Pour faire vite je suis en prépa et je doit créer une maquette, et le programme qui va avec mais je n'y connais pas grand chose en Arduino.
Bref j'ai réussi a créer un luxmètre qui me renvoie toute les seconde l'intensité de la luminosité capté par un tsl2561 en µmol/m2/s.
Mais j'aimerais qu'il me renvoie un compteur qui additionne cette valeur toute les seconde:
si on capte 1 µmol/m2/s, je veux que ma variable compteur me m'affiche 10µmol/m2 au bout de 10s.
voici le programme en question, la partie a modifier se trouve surement a la fin.

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>
  
Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345);
/**************************************************************************/
/*
   Displays some basic information on this sensor from the unified
   sensor API sensor_t type (see Adafruit_Sensor for more information)
*/
/**************************************************************************/
void displaySensorDetails(void)
{
 sensor_t sensor;
 tsl.getSensor(&sensor);
 Serial.println("------------------------------------");
 Serial.print  ("Sensor:       "); Serial.println(sensor.name);
 Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
 Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
 Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" lux");
 Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" lux");
 Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" lux");  
 Serial.println("------------------------------------");
 Serial.println("");
 delay(500);
}
/**************************************************************************/
/*
   Configures the gain and integration time for the TSL2561
*/
/**************************************************************************/
void configureSensor(void)
{
 /* You can also manually set the gain or enable auto-gain support */
 // tsl.setGain(TSL2561_GAIN_1X);      /* No gain ... use in bright light to avoid sensor saturation */
 // tsl.setGain(TSL2561_GAIN_16X);     /* 16x gain ... use in low light to boost sensitivity */
 tsl.enableAutoRange(true);            /* Auto-gain ... switches automatically between 1x and 16x */
 
 /* Changing the integration time gives you better sensor resolution (402ms = 16-bit data) */
 tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */
 // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);  /* medium resolution and speed   */
 // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_402MS);  /* 16-bit data but slowest conversions */
 /* Update these values depending on what you've set above! */  
 Serial.println("------------------------------------");
 Serial.print  ("Gain:         "); Serial.println("Auto");
 Serial.print  ("Timing:       "); Serial.println("13 ms");
 Serial.println("------------------------------------");
}
/**************************************************************************/
/*
   Arduino setup function (automatically called at startup)
*/
/**************************************************************************/
void setup(void) 
{
 Serial.begin(9600);
 Serial.println("Light Sensor Test"); Serial.println("");
 
 /* Initialise the sensor */
 //use tsl.begin() to default to Wire, 
 //tsl.begin(&Wire2) directs api to use Wire2, etc.
 if(!tsl.begin())
 {
   /* There was a problem detecting the TSL2561 ... check your connections */
   Serial.print("Ooops, no TSL2561 detected ... Check your wiring or I2C ADDR!");
   while(1);
 }
 
 /* Display some basic information on this sensor */
 displaySensorDetails();
 
 /* Setup the sensor gain and integration time */
 configureSensor();
 
 /* We're ready to go! */
 Serial.println("");
}
/**************************************************************************/
/*
   Arduino loop function, called once 'setup' is complete (your own code
   should go here)
*/
/**************************************************************************/
void loop(void) 
{  
 /* Get a new sensor event */ 
 sensors_event_t event;
 tsl.getEvent(&event);

 /* Display the results (light is measured in lux) */
 if (event.light)
 {
   Serial.print(event.light*0.000578108); Serial.println("µmol/m2/s ");
 }
 else
 {
   /* If event.light = 0 lux the sensor is probably saturated
      and no reliable data could be generated! */
   Serial.println("Sensor overload");
 }
 delay(1000);

}

Merci de votre aide

Pour avoir de l'aide il vaut mieux respecter les règles du forum

Merci de corriger votre post ci dessus et rajoutez les code tags autour du code:

[code]

[color=blue]// votre code ici[/color]

[/code]

.

ça doit ressembler à cela:

// votre code ici

(faites aussi ctrl-T (PC) or cmd-T (Mac) dans l'IDE avant de copier le code pour qu'il soit indenté correctement)


Votre loop comporte un delay(1000); donc vous attendez 1s à la fin avant de boucler, ce qui fait que vous faites une lecture par seconde en gros.

vous pourriez déclarer 2 variables globales

int compteur = 0;
double cumulLux = 0;

et au lieu de faire l'affichage toutes les secondes vous remplacez dans la loop par

  /* Display the results (light is measured in lux) */
  if (event.light) {
    cumulLux += event.light;
    compteur++;
    if (compteur >= 10) {
      Serial.print(cumulLux); Serial.println("lux cumulés au bout de 10s");
      compteur = 0;
      cumulLux = 0;
    }
  } else   {
    /* If event.light = 0 lux the sensor is probably saturated
       and no reliable data could be generated! */
    Serial.println("Sensor overload");
  }

ici on remet le cumul à 0, à vous de voir ce que vous voulez faire
ce n'est pas super précis car la boucle ne prend pas pile 1s

merci beaucoup J_M_L, Merci beaucoup de m'avoir accordé de votre temps.

La modification du programme fonctionne parfaitement. Désoler pour le code, je suis nouveau je ne savais pas comment le citer.
Mon moniteur m'affiche maintenant le cumul de luminosité toute les 10s que je compte passer a 60s pour plus de donné. Mon objectif maintenant est que lorsque la variable CumulLux dépasse une certaine valeur que je puisse gérer, 2 moteur se mettent a fonctionner pendant une durée t. Ensuite un bouton permettrai de faire tourner les moteur pendant une durée t mais dans le sens contraire (remise en position initiale°. Cela me parait impossible a faire, je vais faire des recherches pour trouver une solution.
Si jamais quelqu'un sait comment procéder je suis preneur car je n'y connais rien, je n'ai malheureusement pas le temps d'apprendre car en prépa et concours dans 3 mois.
Merci de m'avoir lu
Voici le code:

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>
int compteur = 0;
double cumulLux = 0;

   
Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345);
/**************************************************************************/
/*
    Displays some basic information on this sensor from the unified
    sensor API sensor_t type (see Adafruit_Sensor for more information)
*/
/**************************************************************************/
void displaySensorDetails(void)
{
  sensor_t sensor;
  tsl.getSensor(&sensor);
  Serial.println("------------------------------------");
  Serial.print  ("Sensor:       "); Serial.println(sensor.name);
  Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
  Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
  Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" lux");
  Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" lux");
  Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" lux");  
  Serial.println("------------------------------------");
  Serial.println("");
  delay(500);
}

/**************************************************************************/
/*
    Configures the gain and integration time for the TSL2561
*/
/**************************************************************************/
void configureSensor(void)
{
  /* You can also manually set the gain or enable auto-gain support */
  // tsl.setGain(TSL2561_GAIN_1X);      /* No gain ... use in bright light to avoid sensor saturation */
  // tsl.setGain(TSL2561_GAIN_16X);     /* 16x gain ... use in low light to boost sensitivity */
  tsl.enableAutoRange(true);            /* Auto-gain ... switches automatically between 1x and 16x */
  
  /* Changing the integration time gives you better sensor resolution (402ms = 16-bit data) */
  tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */
  // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);  /* medium resolution and speed   */
  // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_402MS);  /* 16-bit data but slowest conversions */

  /* Update these values depending on what you've set above! */  
  Serial.println("------------------------------------");
  Serial.print  ("Gain:         "); Serial.println("Auto");
  Serial.print  ("Timing:       "); Serial.println("13 ms");
  Serial.println("------------------------------------");
 
}

/**************************************************************************/
/*
    Arduino setup function (automatically called at startup)
*/
/**************************************************************************/
void setup(void) 
{
  Serial.begin(9600);
  Serial.println("Light Sensor Test"); Serial.println("");
  
  /* Initialise the sensor */
  //use tsl.begin() to default to Wire, 
  //tsl.begin(&Wire2) directs api to use Wire2, etc.
  if(!tsl.begin())
  {
    /* There was a problem detecting the TSL2561 ... check your connections */
    Serial.print("Ooops, no TSL2561 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }
  
  /* Display some basic information on this sensor */
  displaySensorDetails();
  
  /* Setup the sensor gain and integration time */
  configureSensor();
  
  /* We're ready to go! */
  Serial.println("");
}

/**************************************************************************/
/*
    Arduino loop function, called once 'setup' is complete (your own code
    should go here)
*/
/**************************************************************************/
void loop(void) 
{  
  /* Get a new sensor event */ 
  sensors_event_t event;
  tsl.getEvent(&event);
 
  /* Display the results (light is measured in lux) */
  if (event.light)
  {
    cumulLux += event.light;
    compteur++;
    if (compteur >= 10) {
      Serial.print(cumulLux); Serial.println("lux cumulés au bout de 10s");
      compteur = 0;
      cumulLux = 0;
  }}
  else
  {
    /* If event.light = 0 lux the sensor is probably saturated
       and no reliable data could be generated! */
    Serial.println("Sensor overload");
  }
  delay(1000);
}                  [code]

Ce serait bien d’éditer le premier post pour rajouter les balises de code...

Pour bien comprendre les moteurs (et pour bien débuter avec l’arduino), c’est bien de lire Le mouvement grâce aux moteurs - les tutos d’eskimon.

Ensuite une fois que vous savez piloter un moteur vous déclenchez l’ordre d’allumage quand le seuil est dépassé.

Vous rajoutez deux variables globales, une moteurTourne booléenne qui mémorisera l’état du moteur, initialement a false et une variable unsigned long topDepart qui va mémoriser le moment (millis()) de cet allumage.

Puis dans la loop vous testez si moteurTourne est vrai alors vous regardez combien de temps s’est écoulé

if (moteurTourne && (millis() - topDepart >= 10000ul) {
  // 10 secondes écoulées, on arrête le moteur
  ... a faire
  moteurTourne = false;
}

pour simplifier votre gestion des boutons, éventuellement utilisez la librairie de @bricoleau ou alors la librairie OneButton de Matthias Hertel.

Dans votre loop (ou le callback de la seconde bibliothèque) vous testez l’appui du bouton et faites le nécessaire.

Votre spécification fonctionnelle n’est pas claire cependant, que se passe t’il si le moteur a tourné et personne n’a appuyé le bouton et le seuil de lux est à nouveau dépassé ? Le moteur doit il se relancer ? Que se passe t il si on appuie le bouton pendant que le moteur tourne ? Et s’il n’a pas tourné ?

Au final c’est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement). Il faut définir votre graphe des états, transitions et conditions pour ces transitions et actions associees

conseil d'un vieux qui est passé par la prépa :
mets tout ça de côté pour 3 mois et bosse tes concours.
C'est rien 3 mois...

Si jamais quelqu'un sait comment procéder je suis preneur car je n'y connais rien, je n'ai malheureusement pas le temps d'apprendre car en prépa et concours dans 3 mois.

est-ce un projet pour la prépa ?

si ce n'est pas le cas, +1 avec @biggil

Oui c'est pour mon TIPE donc il faut que je le travaille. Le compteur marche parfaitement, merci beaucoup a vous tous.

Mais maintenant pour plus de précision j'aurais aimé calculer l'intensité lumineuse avec 3 capteur et faire la moyenne des 3. J'aurais donc bien voulu connecter mes 3 capteur sur les broches analogique de mon Arduino et utiliser 3 fois le même code en changeant juste le numéro des broches. Mais dans le code, je remarque que a aucun moment on appelle les broches de mon capteur (A4,A5). Je ne sais donc pas comment modifier mon code pour mesurer avec 3 capteur.

A4 et A5 c'est pour discuter en I2C - même si ce sont les broches analogiques, elles ne sont pas utilisées en tant que tel.

l'I2C, c'est un "bus informatique" et vous pouvez avoir plusieurs éléments actifs sur ce bus, ils sont identifiés chacun par une adresse qui permet de discuter avec un élément précis sur le bus.

Le Capteur de luminosité TSL2561 dispose justement de cette interface numérique I2C et certains capteurs vous permettent de sélectionner une adresse parmi 3, et donc de connecter jusqu’à 3 capteurs de lumière en I2C juste en changeant les adresses des 3 modules pour qu'ils en aient une unique.

dans l'instanciation du composant (la variable tsl)Adafruit_TSL2561_Unified tsl = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 12345); vous passez un paramètre (TSL2561_ADDR_FLOAT) qui est défini dans le .h de Adafruit

// I2C address options
#define TSL2561_ADDR_LOW (0x29)   ///< Default address (pin pulled low)
#define TSL2561_ADDR_FLOAT (0x39) ///< Default address (pin left floating)
#define TSL2561_ADDR_HIGH (0x49)  ///< Default address (pin pulled high)

ce qui définit une des 3 adresses.

pour vos 3 capteurs vous allez donc faire un truc du genre

Adafruit_TSL2561_Unified tsl1 = Adafruit_TSL2561_Unified(TSL2561_ADDR_LOW, 290);
Adafruit_TSL2561_Unified tsl2 = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 390);
Adafruit_TSL2561_Unified tsl3 = Adafruit_TSL2561_Unified(TSL2561_ADDR_HIGH, 490);

et vous aurez 3 capteurs. (le mieux serait de faire un tableau sans doute)

Je ne voudrais pas vous foutre la trouille, mais vous avez une épreuve orale sur votre TIPE. Vous n'êtes pas le seul à vous faire aider pour le TIPE, mais soyez conscient du fait que les examinateurs le savent très bien. Donc les questions qu'ils vont vous poser auront pour but de déterminer si vous avez tout étudié, réalisé et donc compris, dans ce TIPE. Si vous prenez un bout de code que quelqu'un vous donne pour vous aider et que vous l'intégrez dans le projet sans trop comprendre, parce que vous êtes pressé et que vous avez le concours dans 3 mois, vous prenez le risque que l'examinateur vous interroge là dessus et que vous ne sachiez pas répondre, ou que vous répondiez une grosse bêtise. Sachez aussi que les examinateurs se répartissent les candidats en fonction des sujets, donc avec un sujet "Arduino" vous pouvez tomber sur un prof qui est une bête en programmation. Comme il connait très bien le niveau des élèves de prépa sur cette matière, il peut assez facilement détecter si une manière de faire dans un programme lui parait chelou pour avoir été réalisée en autonomie. Donc la question piège va porter là dessus. Un taupin averti en vaut deux... bonne chance.

Ah oui, autre chose : un organe qui additionne à chaque pas de temps la valeur d'une quantité variable, en général en maths on appelle ça un intégrateur, et si S est le symbole de l'intégrale entre 0 et t, on écrit ça I = S f(t).dt. C'est encore au programme de taupe, l'intégration ?

..... les questions qu'ils vont vous poser auront pour but de déterminer si vous avez tout étudié, réalisé et donc compris, dans ce TIPE. Si vous prenez un bout de code que quelqu'un vous donne pour vous aider et que vous l'intégrez dans le projet sans trop comprendre, parce que vous êtes pressé et que vous avez le concours dans 3 mois, vous prenez le risque que l'examinateur vous interroge là dessus

il peut assez facilement détecter si une manière de faire dans un programme lui parait chelou pour avoir été réalisée en autonomie. Donc la question piège va porter là dessus

je confirme !
et les examinateurs s'ils ont eu le temps d'éplucher les dossiers au préable y repèrent assez facilement les bons 'sondages' à opérer à l'oral... année après année leur flair s'améliore....

Merci J-M-L pour votre réponse. J'ai donc voulu tester avec les code que vous m'avez donné pour voir si cela fonctionne. Voici le code. Les parties modifié se trouvent après les #include:

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>

// I2C address options

#define TSL2561_ADDR_LOW (0x29)   ///< Default address (pin pulled low)
#define TSL2561_ADDR_FLOAT (0x39) ///< Default address (pin left floating)
#define TSL2561_ADDR_HIGH (0x49)  ///< Default address (pin pulled high)

   
Adafruit_TSL2561_Unified tsl1 = Adafruit_TSL2561_Unified(TSL2561_ADDR_LOW, 290);
Adafruit_TSL2561_Unified tsl2 = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 390);
Adafruit_TSL2561_Unified tsl3 = Adafruit_TSL2561_Unified(TSL2561_ADDR_HIGH, 490);


/**************************************************************************/
/*
    Displays some basic information on this sensor from the unified
    sensor API sensor_t type (see Adafruit_Sensor for more information)
*/
/**************************************************************************/
void displaySensorDetails(void)
{
  sensor_t sensor;
  tsl.getSensor(&sensor);
  Serial.println("------------------------------------");
  Serial.print  ("Sensor:       "); Serial.println(sensor.name);
  Serial.print  ("Driver Ver:   "); Serial.println(sensor.version);
  Serial.print  ("Unique ID:    "); Serial.println(sensor.sensor_id);
  Serial.print  ("Max Value:    "); Serial.print(sensor.max_value); Serial.println(" lux");
  Serial.print  ("Min Value:    "); Serial.print(sensor.min_value); Serial.println(" lux");
  Serial.print  ("Resolution:   "); Serial.print(sensor.resolution); Serial.println(" lux");  
  Serial.println("------------------------------------");
  Serial.println("");
  delay(500);
}

/**************************************************************************/
/*
    Configures the gain and integration time for the TSL2561
*/
/**************************************************************************/
void configureSensor(void)
{
  /* You can also manually set the gain or enable auto-gain support */
  // tsl.setGain(TSL2561_GAIN_1X);      /* No gain ... use in bright light to avoid sensor saturation */
  // tsl.setGain(TSL2561_GAIN_16X);     /* 16x gain ... use in low light to boost sensitivity */
  tsl.enableAutoRange(true);            /* Auto-gain ... switches automatically between 1x and 16x */
  
  /* Changing the integration time gives you better sensor resolution (402ms = 16-bit data) */
  tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */
  // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_101MS);  /* medium resolution and speed   */
  // tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_402MS);  /* 16-bit data but slowest conversions */

  /* Update these values depending on what you've set above! */  
  Serial.println("------------------------------------");
  Serial.print  ("Gain:         "); Serial.println("Auto");
  Serial.print  ("Timing:       "); Serial.println("13 ms");
  Serial.println("------------------------------------");
}

/**************************************************************************/
/*
    Arduino setup function (automatically called at startup)
*/
/**************************************************************************/
void setup(void) 
{
  Serial.begin(9600);
  Serial.println("Light Sensor Test"); Serial.println("");
  
  /* Initialise the sensor */
  //use tsl.begin() to default to Wire, 
  //tsl.begin(&Wire2) directs api to use Wire2, etc.
  if(!tsl.begin())
  {
    /* There was a problem detecting the TSL2561 ... check your connections */
    Serial.print("Ooops, no TSL2561 detected ... Check your wiring or I2C ADDR!");
    while(1);
  }
  
  /* Display some basic information on this sensor */
  displaySensorDetails();
  
  /* Setup the sensor gain and integration time */
  configureSensor();
  
  /* We're ready to go! */
  Serial.println("");
}

/**************************************************************************/
/*
    Arduino loop function, called once 'setup' is complete (your own code
    should go here)
*/
/**************************************************************************/
void loop(void) 
{  
  /* Get a new sensor event */ 
  sensors_event_t event;
  tsl.getEvent(&event);
 
  /* Display the results (light is measured in lux) */
  if (event.light)
  {
    Serial.print(event.light); Serial.println(" lux");
  }
  else
  {
    /* If event.light = 0 lux the sensor is probably saturated
       and no reliable data could be generated! */
    Serial.println("Sensor overload");
  }
  delay(1000);
}

Le code ne comporte pas d'erreur mais avec le moniteur, la communication ne parvient pas a s'effectuer.
En fait dans la suite du code, il y a une seule variable de déclaré: la variable "tsl". Or, dans les commande Adafruit..., ce sont des variable tsl1,tsl2,tsl3 qui sont utilisé. Est ce que le problème ne viendrais t'il pas de la ? Si oui, comment puis-je faire ? Peut être qu'il faut a chaque fois remplacer par exemple

 tsl.getEvent(&event)

par

tsl1.getEvent(&event);
tsl2.getEvent(&event);
tsl3.getEvent(&event);

Cette solution n'es qu'une supposition
J'ai testé cette solution mais je pense avoir faire beaucoup trop d'erreur dans le code, donc je ne sais pas si cette solution marche
Merci de votre aide.

PS: Pour ce qui es de mon TIPE, le codage Arduino me sert uniquement a acquérir un rayonnement lumineux, ce qui représente une infime partie du TIPE. Effectivement, il est préférable de tout comprendre a son TIPE. Je ne suis pas doué en Arduino et n'ai pas le temps d'apprendre d'ici l'oral, donc j'essaye juste de comprendre dans les grandes ligne les codes. Merci de vos conseil

Vous partez de loin...

le #include définira les 3 adresses donc pas la peine de les remettre.

Bien entendu il faut aussi câbler les 3 modules de façon correcte pour qu’ils aient la bonne adresse sinon ça ne fonctionnera pas

Oui on crée trois variables, chacune représentant un des capteurs donc il faut ensuite utiliser ces variables dans le code mais si vous faites

tsl1.getEvent(&event);
tsl2.getEvent(&event);
tsl3.getEvent(&event);

vous mettez le résultat dans la même variable event. il serait peut-être bon d'en avoir 3

tapé ici - ça pourrait ressembler à cela

#include <Adafruit_Sensor.h>
#include <Adafruit_TSL2561_U.h>

Adafruit_TSL2561_Unified tsl1 = Adafruit_TSL2561_Unified(TSL2561_ADDR_LOW, 290);
Adafruit_TSL2561_Unified tsl2 = Adafruit_TSL2561_Unified(TSL2561_ADDR_FLOAT, 390);
Adafruit_TSL2561_Unified tsl3 = Adafruit_TSL2561_Unified(TSL2561_ADDR_HIGH, 490);

void displaySensorDetails(Adafruit_TSL2561_Unified & tsl, byte id)
{
  sensor_t sensor;
  tsl.getSensor(&sensor);
  Serial.println(F("------------------------------------"));
  Serial.print(F("             SENSOR #")); Serial.println(id);
  Serial.println(F("------------------------------------"));
  Serial.print(F("Sensor:       ")); Serial.println(sensor.name);
  Serial.print(F("Driver Ver:   ")); Serial.println(sensor.version);
  Serial.print(F("Unique ID:    ")); Serial.println(sensor.sensor_id);
  Serial.print(F("Max Value:    ")); Serial.print(sensor.max_value); Serial.println(F(" lux"));
  Serial.print(F("Min Value:    ")); Serial.print(sensor.min_value); Serial.println(F(" lux"));
  Serial.print(F("Resolution:   ")); Serial.print(sensor.resolution); Serial.println(F(" lux"));
  Serial.println(F("------------------------------------\n"));

}

void configureSensors(void)
{
  tsl1.enableAutoRange(true);            /* Auto-gain ... switches automatically between 1x and 16x */
  tsl2.enableAutoRange(true);            /* Auto-gain ... switches automatically between 1x and 16x */
  tsl3.enableAutoRange(true);            /* Auto-gain ... switches automatically between 1x and 16x */

  tsl1.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */
  tsl2.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */
  tsl3.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);      /* fast but low resolution */

  Serial.println(F("------------------------------------"));
  Serial.println(F("Gain:\t\tAuto"));
  Serial.println(F("Timing:\t\t13 ms"));
  Serial.println(F("------------------------------------"));
}


void setup(void)
{
  Serial.begin(115200);
  Serial.println(F("Light Sensor Test\n"));

  /* Initialise the sensors */
  if (!tsl1.begin()) {
    Serial.print(F("Error tls1 - Check your wiring or I2C ADDR!"));
    while (1);
  }
  displaySensorDetails(tsl1, 1);

  if (!tsl2.begin()) {
    Serial.print(F("Error tls2 - Check your wiring or I2C ADDR!"));
    while (1);
  }
  displaySensorDetails(tsl2, 2);


  if (!tsl3.begin()) {
    Serial.print(F("Error tls3 - Check your wiring or I2C ADDR!"));
    while (1);
  }
  displaySensorDetails(tsl3, 3);

  /* Setup the sensor gain and integration time */
  configureSensors();

  /* We're ready to go! */
  Serial.println();
}


void loop(void)
{
  sensors_event_t event1, event2, event3;
  tsl1.getEvent(&event1);
  tsl2.getEvent(&event2);
  tsl3.getEvent(&event3);

  if (event1.light) {
    Serial.print(F("#1\t")); Serial.print(event1.light); Serial.println(" lux");
  }

  if (event2.light) {
    Serial.print(F("#2\t")); Serial.print(event2.light); Serial.println(" lux");
  }

  if (event3.light) {
    Serial.print(F("#3\t")); Serial.print(event3.light); Serial.println(" lux");
  }
  Serial.println();

  delay(1000);
}

il y a beaucoup de code qui se répète, c'est pour cela que mettre un tableau pour les 3 capteurs et faire une boucle for() pour traiter chaque capteur serait pas mal.

Ensuite - je rejoins mes petits camarades, faut maitriser un minimum tous ce qui rentrera dans votre projet ou être clair sur ce que vous avez fait versus obtenu et expliquer voter prioritisation

Oui je pars de loin

Je suis prêt a rémunérer quelqu'un pour qu'il m'aide, j'ai vraiment besoin d'arriver a réaliser ceci car cela bloque totalement mon avancé pour mon TIPE.
Petit rappel, j'ai 3 capteur TSL2561. Mon objectif est de mesurer un rayonnement lumineux en faisant la moyenne des valeurs mesuré par les 3 capteur. Je bloque sur le code. Lorsque j'utilise le programme de test du capteur, j'arrive a mesurer la luminosité grâce a 1 capteur branché sur les ports A4A5 (les autre capteur sont inactifs. Il faudrait réussir a mesurer en utilisant les ports allant de A0 a A3. Voici mon montage actuel.

Merci de votre aide.

Payer pour faire le job à votre place est une très mauvaise idée.

J’ai déjà expliqué que c’est un bus, pas une lecture analogique donc on ne branche pas ailleurs.

Ça veut dire que vous branchez TOUS les trois capteurs sur A4 et A5, mais il faut modifier le branchement d’une broche sur chacun des modules pour qu’ils aient une adresse différente sur le bus.

(Prenez 10 minutes pour lire ce qu’est un bus et ce qu’est le I2C)

La broche ADDR peut être utilisée pour choisir l'adresse i2c, pour changer l'adresse. Connectez-le à la terre pour définir l'adresse sur 0x29, connectez-le à 3,3V (vcc) pour définir l'adresse sur 0x49 ou laissez-le flottant (non connecté) pour utiliser l'adresse 0x39.

C’est ce qui permettra à votre arduino de voir les 3 modules. Faites la connexion qui va bien pour led 3 modules donc sur la broche ADDR et Testez avec le code que j’ai posté

Je sais mais malheureusement le temps presse et cette partie de code ne fait pas partie de mon évaluation.

Merci pour vos explication précieuses. Le problème est que mon capteur ne comporte que les prise SDA, SCL, VCC, GND, INT mais pas la broche ADDR dont vous parlez. J’ai effectivement vu des capteur avec ce genre de broche mais pas les miens. Je vais essayer de voir si la borne INT peut permettre de différencier les adresses I2C.
Merci beaucoup à vous pour le temps que vous m’accordez.

Bonjour
INT : Le capteur peut , sous conditions, envoyer un signal d'interruption au processeur

Adresse : je ne connais pas ce capteur mais il se pourrait bien que les terminaisons L et H permettent d'attribuer à un capteur une adresse parmi n.

Chercher des infos sur le BUS I2C et sur votre module qui offre eut être une possibilité de définition d'adresse en plaçant (ou pas) un pont de soudure entre le point central et L ou H
LH.png

LH.png

Bonjour,

Mets le lien sur ton capteur.
Sur certain modules capteur, il y a possibilité de faire des ponts de soudure ou straps pour changer l'adresse.

Si vous ne pouvez pas changer les adresses I2C vous êtes coincé - sans matériel supplémentaire vous ne pourrez pas simplement piloter les 3 dans le même montage

Une photo de bonne qualité des deux faces du capteur devrait nous permettre de voir si un point de soudure peut résoudre le problème, par exemple si vous avez quelque chose comme cela

Le pad ("petit bout brillant") du milieu est la broche ADDR.

  • si vous ne faites rien, elle est "en l'air" (flottante - on voit bien qu'il n'y a pas de piste qui part du pad pour être connecté quelque part) et l'adresse est 0x39. (TSL2561_ADDR_FLOAT)
  • si vous mettez un point de soudure entre le milieu et le pad à gauche (H pour HIGH), alors vous avez mis ADDR à HIGH et le module est à l'adresse 0x49 (TSL2561_ADDR_HIGH)
  • si vous mettez un point de soudure entre le milieu et le pad à droite (L pour LOW ou GND), alors vous avez mis ADDR à LOW et le module est à l'adresse 0x29 (TSL2561_ADDR_LOW)

les 3 pads avec H et L sont bien présents sur la carte d'antoinedufau82 (cf message #15 avec un extrait de la photo jointe à son message #12) .... il est donc 'sauvé' !!

OK - je n'avais pas cliqué sur le lien d'antoinedufau82

reste plus qu'à trouver un fer à souder et un peu de soudure pour faire la modification.

Voici la photo - il faudra câbler correctement sur le bus I2C, donc utilisation de A4 et A5 pour les 3 cartes et ne rien brancher sur A0-A3 pour les cartes

Le montage doit donc ressembler à cela: