Comment faire un for dans un struct

Bonjour,

D’abord je ne sais pas si j’ai fais un bon choix,mais je vous explique ce que j’ai fait et ce que j’essaye de faire.

D’abord, j’ai déclaré un struct

struct sensor1{
  char battery[20];
  char temperature[20];
  char pression[20];
  char humidity[20];
  char luminosity[20];
  char alt[20];
  char latitude[20];
  char longitude[20];
  char datetime[20];
};

sensor1 Sensors1 = {
  "",
  "",
  "",
  "",
  "",
  "",
  "",
  "",
  "",
};

Puis dans ma loop(){}, je relève les mesures de mes capteurs. la température, je la sauve das

Sensors1.temperature

etc…

A la fin de ma loop(), j’ai la fonction

do_send(&sendjob);

C’est une fonction qui fonctionne sauf que je n’ai pas compris pourquoi je ne pouvais pas ajouter de parametre. Pour rester concentré sur une question, je ne vais pas détailler le cas.

Donc pour parer à ceci, j’ai créé un struct.

(Sur le coup, je me demande si j’aurais pas du utiliser un array
A l’index 1, je sauve la température, au index suivant, la pression, etc…)

L’aventage de la trcture que je vois, c’est que je peux afficher un résultat sachant ce que je veux afficher. C’est à dire

Sensors1.pression //j’affiche la pression
Sensors1.alt //j’affiche l’alitude

Alors que dans l’array, je dois me souvenir d’un numéro…

Le problème, maintenant, c’est que je ne sais pas comment je peux faire un for dans un truct

Dans un array, je peux faire ceci

for(ind=1;ind<3:ind++)
{
Serial.println(toto[ind]);
}

Comment je peux faire ceci avec un struct

Ceci ne fonctionne pas, évidemment

for(int i=0;i<3;i++)
  {
    Serial.println(Sensors1[i]);
  }

car mes index sont des “nom…”

Et serait-il possible d’affiche la valeur et le “nom”?

Si non, serait-il pas mieux que je travaille avec in tableau?
Que me suggriez-vous de mieux?

Merci pour vos lumières

Peut-être utilises-tu mal la structure.
Une structure contient un ensemble de variables que l'on peut facilement passer en paramètre à une fonction en lui passant un pointeur en paramètre.
Si tu as plusieurs groupes de capteurs que tu veux manipuler il serait plus judicieux de faire un tableau de structures et non pas une structure contenant des tableaux.

Salut, merci pour ta réponse.

J'ai du mal à suivre mon développement selon tes recommendations.
Puis-je te demander un exemple de tableau de structure?

Ne serat-il pas plus simple de faire un tableau "tout court"

J'avais une fois fait comme ceci

#define SD_DEEPSIZE 8
char * sd_deep[SD_DEEPSIZE];

sd_deep[tabulation] = getNameFile;

tabulation étant un byte qui va correspondre à un capteur, et getNameFile un char.

Je ne sais pas trop ce qui le plus aventageux...

Ce qui serait intéressant ce serait de comprendre le besoin.
Tu as vraiment besoin de gérer 20 groupes de capteurs?

Non, j'en ai que 8.
Le problème c'est que doit construire une chaîne json. Il y a des capteurs qui peuvent être active ou pas. Donc je ne sais pas comment gérer les virgules qui sépare un élément d'une chaîne json,dans le cas où un capteur est inactif.
Peut être que je compliqué la vie.
Mais je pensais mettre ceci dans un Array ou un struc, ét enregistrer que les capteurs actif, dans le tableau.
Puis faire un for dans le tableau et ne pas afficher la virgule lors du dernier index.
Je voulais faire ceci avec mon struc, mais j n'arrive justement pas à parcourir ce dernier.
Sans pouvoir l'expliquer j'ai une préférence pour un struct, mais je dois avouer que je ne sais pas justifier l'aventage d'un struct a un array

Donc si je comprends bien

vous avez un ensemble possible de capteurs. un capteur peut être actif ou pas.
vous devez, pour l’ensemble des capteurs actifs, enregistrer un historique de mesures.
Enfin vous devez pouvoir afficher un JSON contenant l’ensemble des valeurs lues pour l’ensemble des capteurs actifs

Vous avez donc besoin de décrire ce qu’est un capteur et c’est quoi une mesure et prévoir une zone mémoire assez large pour tous les capteurs, par exemple un tableau à 2 dimensions avec une ligne par capteur possible et n colonnes pour la mémoire des mesures

un truc du genre

struct capteur
{
  uint8_t pinDuCapteur;
  boolean actif;
  const char * nomDuCapteur;
};

capteur mesCapteur[] = {
  {3, true, "battery"},
  {4, true, "temperature"},
  {5, false, "pression"},
  {6, true, "humidity"},
  {7, true, "luminosity"},
};

enum : byte {battery = 0, temperature, pression, humidity, luminosity}; // dans le même ordre que mesCapteurs

const byte nbMaxCapteurs = sizeof(mesCapteur) / sizeof(mesCapteur[0]);

struct mesure {
  uint32_t chrono; // moment de la mesure
  uint16_t valeur; // valeur mesurée (adapter le type)
  // autre chose de pertinent à mémoriser lors d'une mesure ?
};

const byte tailleHistorique = 5;
mesure mesMesures[nbMaxCapteurs][tailleHistorique];


void setup() {
  Serial.begin(115200);

  // imprimer la liste des capteurs
  Serial.println(F("Liste des capteurs"));
  Serial.println(F("------------------------"));

  for (byte i = 0; i < nbMaxCapteurs; i++) {
    Serial.print(F("Capteur: ["));
    Serial.print(mesCapteur[i].nomDuCapteur);
    Serial.print(F("]\t"));
    Serial.print(F("actif: ")); Serial.print(mesCapteur[i].actif ? F("VRAI") : F("FAUX"));
    Serial.print(F("\tsur pin: ")); Serial.println(mesCapteur[i].pinDuCapteur);
  }


  // écrire une valeur, l'enum nous aide à représenter facilement le capteur
  mesMesures[battery][0].valeur = 17;
  mesMesures[battery][0].chrono = micros();

  mesMesures[humidity][3].valeur = 22;
  mesMesures[humidity][3].chrono = micros();


  // imprimer uniquement les valeurs mémorisées des capteurs actifs
  Serial.println();
  Serial.println(F("Historique des capteurs actifs"));
  Serial.println(F("------------------------"));

  for (byte i = 0; i < nbMaxCapteurs; i++) {
    if (mesCapteur[i].actif) { // si le capteur n'est pas actif on n'imprime pas
      Serial.print(F("Capteur: ["));
      Serial.print(mesCapteur[i].nomDuCapteur);
      Serial.print(F("]\t{"));
      for (byte j = 0; j < tailleHistorique; j++) {
        Serial.print(mesMesures[i][j].valeur);
        if (j < tailleHistorique - 1) Serial.print(F(","));
      }
      Serial.println(F("}"));
    }
  }
}

void loop() {}

vous affichera sur la console (réglée à 115200 bauds)

```
[color=blue]Liste des capteurs

Capteur: [battery] actif: VRAI sur pin: 3
Capteur: [temperature] actif: VRAI sur pin: 4
Capteur: [pression] actif: FAUX sur pin: 5
Capteur: [humidity] actif: VRAI sur pin: 6
Capteur: [luminosity] actif: VRAI sur pin: 7

Historique des capteurs actifs

Capteur: [battery] {17,0,0,0,0}
Capteur: [temperature] {0,0,0,0,0}
Capteur: [humidity] {0,0,0,22,0}
Capteur: [luminosity] {0,0,0,0,0}
[/color]
```

On voit bien que le capteur de pression qui est défini comme inactif n’est pas imprimé et bien sûr les plupart des valeurs sont à 0 parce que je ne les ai pas initialisées mais celles que j’ai définies (les 17 et 22) sont bien là

Ouha!! Merci J_M_L,
C'est super intéressant. Je vais soigneusement regardé ceci.

Je viens de découvrir que je ne dois pas envoyer un string json. Quoi il est très fortement découseillé.

En fait, j'envoie mes données, via une gateway LoRaWAN (TTN).

Le paquet des valeurs des capteurs actif à envoyer doit être en bytes et je vais aussi devoir me concentrer sur comment convertir un double et char en bytes/bit.

MAis super intéressant ton exemple, mille merci pour cette exemple!!!!!!

Pas de soucis avec write()

Salut J-M-L

Je te remercie beaucoup pour ton code. Il est juste super et isntructif.

Cependant, il y a deux trucs que je ne comprends pas trop.

Premièrement, je ne comprends pas ce que fait cette ligne
(J'ai ajouté des capteurs)

enum : byte {c_battery = 0, c_temperature, c_pression, c_alt, c_humidity, c_moistrure, c_luminosity, c_uv, c_latitude,c_longitude,c_datetime}; // dans le même ordre que mesCapteurs

et pourquoi battery est = à 0 et les autres non pas de valeur.

Tu écris plus bas

// écrire une valeur, l'enum nous aide à représenter facilement le capteur
mesMesures[c_luminosity][0].valeur = 17;

C'est un peu flou, pour moi et j'aimerais bien comprendre ce passage, à titre de formation, car mon code fonctionne.

En suivat to exemple, j'ai ceci qui s'impirme. Tout me semble juste

Liste des capteurs

Capteur: [c_battery] actif: FAUX sur pin: 1
Capteur: [c_temperature] actif: VRAI sur pin: 2
Capteur: [c_pression] actif: VRAI sur pin: 3
Capteur: [c_alt] actif: VRAI sur pin: 4
Capteur: [c_humidity] actif: VRAI sur pin: 5
Capteur: [c_moistrure] actif: FAUX sur pin: 6
Capteur: [c_luminosity] actif: VRAI sur pin: 7
Capteur: [c_uv] actif: FAUX sur pin: 8
Capteur: [c_latitutde] actif: FAUX sur pin: 9
Capteur: [c_longitude] actif: FAUX sur pin: 10
Capteur: [c_datetime] actif: FAUX sur pin: 11

Historique des capteurs actifs

Capteur: [c_temperature] {0.00,0.00,0.00,0.00,0.00}
Capteur: [c_pression] {0.00,0.00,0.00,0.00,0.00}
Capteur: [c_alt] {0.00,0.00,0.00,0.00,0.00}
Capteur: [c_humidity] {0.00,0.00,0.00,22.00,0.00}
Capteur: [c_luminosity] {17.00,0.00,0.00,0.00,0.00}

En tout cas, milles mercis!!

Pour l'énumération (enum) le = 0 est en fait facultatif car le premier élément d'une énumération vaut 0 et les autres - dans l'ordre - sont augmentés de 1. Je l'ai mis juste pour montrer/expliquer que c'est l'indice 0 du tableau et les autres suivent en ordre croissant et ça permet d'avoir des noms plus parlants que des indices

Si vous lisez mon tuto sur les machines à états j'explique un peu plus comment un enum fonctionne et à quoi ça sert