Nano: programme bloque

1 pièce(s) jointe(s)

Bonjour à tous

j'aurais besoin de votre aide car j'ai un croquis somme toute simple mais qui "plante" après téléversement
et dont je n'arrive pas à connaître la raison :
celui- ci se compose entre autre de 3 sous programmes de test dans le "loop"
1-ReadVcc()
2-ReadPanels()
3-ReadDHT()

si j'active seulement 2 sous-prg sur 3 et quelque soit l'ordre, cela fonctionne correctement
mais si j'active les 3 , le croquis plante après téléchargement

je mets le croquis sous forme de fichier TXT aussi
un grand merci par avance

pascal

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
 
#include <Adafruit_NeoPixel.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_VL53L0X.h"
#include "DHT.h"
 
#define NUMPIXELS 10 // Popular NeoPixel ring size
#define DELAYVAL 200 // Time (in milliseconds) to pause between pixels
 
 
//----------------------------------------------------------------------
//                        NANO 
//  
//                        ===============    
//                       -|             |- 
//                       -|             |- 
//                       -|             |- 
//      Tension BAT   A0 -|             |-
//      Alarme        A1 -|             |- D8  DONE  
//                       -|   NANO      |- D7  VL53L0X 1
//                       -|             |- D6  VL53L0X 2
//              SDA   A4 -|             |- D5  Panneau 2
//              SCL   A5 -|             |- D4  Panneau 1
//                       -|             |- D3  LDR
//                       -|             |- D2  DHT
//                   +5V -|             |- GND
//                       -|             |- 
//                   GND -|             |- 
//                   DRV -|             |-  
//                        ===============
//-----------------------------------------------------------------------
 
 
// Capteurs vl53l0x..............................
#define pinLOX1  7                  //* Capteur 1           */
#define pinLOX2  6                  //* Capteur 2           */
#define LOX1_ADDRESS         0x30                //* Adresse I2C : 0x30  */
#define LOX2_ADDRESS         0x29                //* Adresse I2C : 0x29  */
#define maxDistance          100                 //* distance max 100 mm */
Adafruit_VL53L0X LOX1      = Adafruit_VL53L0X();
Adafruit_VL53L0X LOX2      = Adafruit_VL53L0X();
VL53L0X_RangingMeasurementData_t measure1;
VL53L0X_RangingMeasurementData_t measure2;
 
// DHT22.........................................
#define pinDHT               2                  
DHT dht(pinDHT, DHT22);                          // DHT22  (AM2302), AM2321
 
// Mesure Batterie...............................
#define pinVp                A0                  //* mesure BATT                                 */
#define VccMin               3.2                 //* Niveau minimum attendu de BAT, en Volts     */
#define VccMax               4.2                 //* Niveau maximum attendu de BAT, en Volts     */
#define VccRange             VccMax - VccMin        
const float Ratio          = 100.0 ;             // Eviter les divisions par la suite
 
 
// Branchements ...................................................... 
#define pinLDR                3                   //* LDR            */
#define pinAlarm             13                   //* Alarme      */
#define DONEPIN               8                   //* TPL5110 pin DONE  */
#define pinP1                 4                   //* Panneau 1 ouvert */
#define pinP2                 5                   //* Panneau 2 ouvert /*
 
// Variables
bool P1                    = 0;                  // 0: ferme, 1: ouvert
bool P2                    = 0;                  // 0: ferme, 1: ouvert
bool isDark                = 0;                  // Luminosité faible
bool isRaining             = 0;                  // Humidité forte
int pp                     = 0;
int tt                     = 0;
int hh                     = 0;
bool n1                    = 0;
bool n2                    = 0;
int  valarme               = 0;
bool donneesEnvoyees       = false;
bool vDHT                  = false;
bool vVCC                  = false;
 
//unsigned long previousMillis = 0; 
//const long interval = 30000;    
 
Adafruit_NeoPixel pixels(NUMPIXELS, pinAlarm , NEO_GRB + NEO_KHZ800);
 
 
void ReadPanels() {  // Lire l'état des panneaux ***********************************************************************
 
   // Capteur1 en lecture........................
   // P1 = 1 si panneau n°1 ouvert
   Serial.print(F("Panneau N°1 => "));
   LOX1.rangingTest(&measure1, false);    // 'true' pour avoir les données de débogage
   //P1 = (measure1.RangeMilliMeter - 10 >  maxDistance); 
   P1 = (measure1.RangeMilliMeter >  maxDistance); 
   Serial.print(P1);
   if(P1) Serial.print(F("- Ouvert")); else Serial.print(F("- Fermé"));
   Serial.println();
 
   // Capteur2 en lecture........................
   // P2 = 1 si panneau n°2 ouvert
   Serial.print(F("Panneau N°2 => "));
   LOX2.rangingTest(&measure2, false);  // 'true' pour avoir les données de débogage
   //P2 = (measure2.RangeMilliMeter - 10 >  maxDistance);
   P2 = (measure2.RangeMilliMeter >  maxDistance);
   Serial.print(P2);
   if(P2) Serial.print(F("- Ouvert")); else Serial.print(F("- Fermé"));
   Serial.println();
 
   if (P1 != 0) digitalWrite(pinP1 , HIGH); else digitalWrite(pinP1 , LOW);
   if (P2 != 0) digitalWrite(pinP2 , HIGH); else digitalWrite(pinP2 , LOW);
 
 }
 
 
void ReadDHT() { // Lire Température et humidité********************************************************************
   float h = dht.readHumidity();
   float t = dht.readTemperature();
   //float correction = 3 ;
   // Check DHT22.
   if(isnan(t) || isnan(h))  {
     Serial.println("Impossible de lire la sonde DHT!");
     return;
   }
   Serial.print("Humidite : ");     Serial.print(round(h));    Serial.println("%");
   Serial.print("Temperature : ");  Serial.print(round(t));    Serial.println("°C");
   tt = t;
   hh = h;
   isRaining = h >= 90.0; // Test =35
   delay(100);
}
 
 
void ReadVcc() { // Lire la tension de la batterie *****************************************************************
 
	  // lire la rension en A0 
    float v = analogRead(pinVp); // AnalogRead renvoi une valeur entre 0 et 1023
    float tension = (v * 1.1) / analogReadReference(); // 1023 correspond à 3,3 Volts sur WEMOS D1 Mini Pro
    float tensionRedressee = (tension / ( 33.74 / ( 33.74 + 110))*0.944 );
    Serial.print("tension Mesurée = " );   Serial.print(tensionRedressee);       Serial.println(" V");
 
	  // Calculer Niveau de charge BATT 
	  int p = round(Ratio*((tensionRedressee-VccMin)));
    if(p > 100) p = 100 ; else if(p < 0) p = 0; 
    pp = p;	
    Serial.print("BAT = ");    Serial.print(pp);     Serial.println(" %");
 
 }
 
 
void alarme() { //******************************************
 
   Serial.print("vAlarme: ");    Serial.print(valarme);      Serial.println();	 
   for(int i=0; i<NUMPIXELS; i++) 
	 { // For each pixel...
 
       if (valarme==1){
          pixels.setPixelColor(i, pixels.Color(255, 0, 255)); // Sombre = VIOLET
       }
       if (valarme==2){
          pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // Pluie = ROUGE
       }   
       if (valarme==3){
          pixels.setPixelColor(i, pixels.Color(0, 255, 0)); // Batterie = VERT
       }
 
        pixels.show();   // Envoyez les couleurs de pixel mises à jour au matériel.
        delay(DELAYVAL); // Pause avant le passage suivant dans la boucle
        pixels.setPixelColor(i, pixels.Color(0, 0, 0));
        pixels.show(); 
   }
 
} 
 
 
void alarmeOFF() { // Alarme OFF*****************************************
    pixels.clear();
	pixels.show(); 
    isDark                = 0;                  // Luminosité faible ?
    isRaining             = 0; 
	valarme = 0;
}	
 
 
void CheckAlarm() { // Vérifier si une alarme est nécessaire ******************
 
    pixels.clear();
    pixels.show(); 
    if ((P1 != 0) || (P2 != 0)) {                                  // > 0 si au moins l'un des panneaux est ouvert
      Serial.println(F("Panneaux ouverts..."));
      if (P1) (n1= 1) ;     // panneau 1 ouvert
      if (P2) (n2= 1) ;     // panneau 2 ouvert
      isDark = digitalRead(pinLDR);
 
     if(isDark || isRaining || (pp<=30) )
     {
       if(isDark) {
         Serial.println(F("Alarme obscurite..."));
         valarme = 1 ;
       }
       if(isRaining) {
        Serial.println(F("Alarme pluie..."));
        valarme  = 2 ;
       }
 
       pp = 100; // Test 
       if(pp<=30) {
        Serial.println(F("Batterie faible..."));
        valarme = 3;
       }
 
     alarme(); 
 
     }else{ 
          Serial.println(F("CheckAlarme ..OK "));
          alarmeOFF();
 
     }  
    } else { // Les deux sont fermés
      Serial.println(F("Panneaux clos..."));
	    alarmeOFF();
    }  
 
}
 
// Initialiser les capteurs d'ouverture des panneaux **********************************************
void setID() {
   // tout est remis à zéro
   digitalWrite(pinLOX1, LOW);                   
   digitalWrite(pinLOX2, LOW);
   delay(10);
   // initialisation LOX1........................
   digitalWrite(pinLOX1, HIGH);
   delay(10);
   if(! LOX1.begin(LOX1_ADDRESS)) {
      Serial.println(F("Échec init 1er VL53L0X"));
      while(1);
    }
   // initialisation LOX2........................
   digitalWrite(pinLOX2, HIGH);
   delay(10);
   if(! LOX2.begin(LOX2_ADDRESS)) {
      Serial.println(F("Échec init 2nd VL53L0X"));
      while(1);
    }
}
 
 
//**************************************************
//             SETUP                               *
//**************************************************
void setup() {
 
   Serial.begin(9600);
   //Wire.begin (); 
 
   pinMode(pinAlarm, OUTPUT);                    // Sortie Alarme
   pinMode(pinLDR,   INPUT);                     // Entree LDR
   pinMode(pinLOX1, OUTPUT);                     // Sortie LOX1  
   pinMode(pinLOX2, OUTPUT);                     // Sortie LOX2
   pinMode(pinP1, OUTPUT);                       // Sortie Panneau 1 Ouvert
   pinMode(pinP2, OUTPUT);                       // Sortie Panneau 2 Ouvert
 
   //pinMode(DONEPIN, OUTPUT);
   //digitalWrite(DONEPIN, LOW);
 
   //Serial.println(F("Broches d'arrêt activées..."));
   digitalWrite(pinLOX1, LOW);
   digitalWrite(pinLOX2, LOW);
   setID();
 
   // Init DHT22
   dht.begin(); 
 
   //Bandes LED Init
   pixels.begin(); // INITIALISER l'objet bande NeoPixel (OBLIGATOIRE)
   pixels.clear(); // Définir toutes les couleurs de pixel à 'off'.
 
   valarme = 0; 
   delay(100);
}   
 
//**************************************************
//             LOOP                                *
//**************************************************
void loop() {
 
      // Position des Panneaux
      ReadPanels();  
      delay(500); 
      /////if ((P1==0)&&(P2==0)) done(); // Si les 2 panneaux sont fermés
 
      // Lecture Temperature & Humidité
      ReadDHT();                 
      delay(500);   
 
       // Lecture Tension batterie 
      ReadVcc();                
      delay(500);
 
      Serial.println() ;
      Serial.print("Sombre ? ");    Serial.print(isDark);      Serial.println();
      Serial.print("Pluie ? ");     Serial.print(isRaining);   Serial.println();
 
      //CheckAlarm();
 
      /*        
      if (valarme==0) {
  		   done();
      } 
      */  
      delay(1000);
}
 
 
 
//**********************************************
// toggle DONE so TPL5110 knows to cut power!
//********************************************** 
void done()
 
{
 delay(500);
 while (1) {
      digitalWrite(DONEPIN, HIGH);
      delay(1);
      digitalWrite(DONEPIN, LOW);
      delay(1);
 }  
}
 
//*********************************************
/** Mesure la référence interne à 1.1 volts */
//*********************************************
unsigned int analogReadReference(void) {
 
  /* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5F;
#endif
  delayMicroseconds(5);
 
  /* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
  ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
  ADCSRB &= ~(1 << MUX5);
  ADMUX = 0x5E;
#endif
  delayMicroseconds(200);
 
  /* Active le convertisseur analogique -> numérique */
  ADCSRA |= (1 << ADEN);
 
  /* Lance une conversion analogique -> numérique */
  ADCSRA |= (1 << ADSC);
 
  /* Attend la fin de la conversion */
  while(ADCSRA & (1 << ADSC));
 
  /* Récupère le résultat de la conversion */
  return ADCL | (ADCH << 8);
}

si vous compilez avec les warnings activés est-ce que vous avez un message qui dit

"La mémoire disponible faible, des problèmes de stabilité pourraient survenir."

si c'est le cas, c'est que vous consommez sans doute trop de mémoire à l'exécution du programme

essayez de regarder l'ensemble des Serial.print() et de vous assurer que vous utilisez la macro F("...") partout. ça libèrera de la SRAM si vous en trouvez, peut-être ce sera suffisant.

1 pièce(s) jointe(s)

Bonjour Jay M

merci d'avoir répondu , je n'ai jamais eu ce type de problème auparavant

voici le message à la compilation :

AVANT

Citation:

Le croquis utilise 22478 octets (73%) de l'espace de stockage de programmes. Le maximum est de 30720 octets.
Les variables globales utilisent 1822 octets (88%) de mémoire dynamique, ce qui laisse 226 octets pour les variables locales. Le maximum est de 2048 octets.
La mémoire disponible faible, des problèmes de stabilité pourraient survenir.

APRES la modification des Serial.print()

Citation:

Le croquis utilise 22462 octets (73%) de l'espace de stockage de programmes. Le maximum est de 30720 octets.
Les variables globales utilisent 1706 octets (83%) de mémoire dynamique, ce qui laisse 342 octets pour les variables locales. Le maximum est de 2048 octets.
La mémoire disponible faible, des problèmes de stabilité pourraient survenir.

Par contre le prg tourne maintenant et je n'aurai jamais trouvé

Pièce jointe 618694

Un grand merci

pascal

ça doit être vraiment juste alors, vous avez économisé une centaine d'octets avec la macro F("...").

tant mieux si ça passe !

Oui ,
j'avoue que c'est vraiment tout juste pour le nano

j'ai essayé d'autres alternatives, comme ESP32 et le Wemos aussi dans la perspective de l'IOT mais j'ai
du abandonner car je n'arrivais à maitriser la consommation d’énergie
je me rabats donc sur le Nano sans IOT ,mais çà m'a l'air d'être très très juste voir peut-être instable

une autre suggestion de support ?

pascal

Citation:

Envoyé par cobra38

une autre suggestion de support ?

J'avais fais une suggestion à base de Nano Every.

1 pièce(s) jointe(s)

Merci Jerome Briot

Exact , et pardon pour la reddit ...(la vieillesse surement )
j'ai cherché effectivement le produit mais il est d'apparence trompeuse et semble identique au nano "simple"
un truc pour le distinguer ?

pascal

Pièce jointe 618698

Citation:

Envoyé par cobra38

un truc pour le distinguer ?

Le microcontrôleur passe d'un ATmega328 sur la Nano à un ATMega4809 sur la Nano Every.

1 pièce(s) jointe(s)

Le look est aussi très différent (pour l'original)

Pièce jointe 618703

Ok merci encore pour les infos
je vais m'en procurer un

Bravo encore pour le dépannage !!
Et grand merci

pascal

As-tu essayé d'utiliser des bibliothèques plus compactes ?

Bonjour "Jerome"

Citation:

As-tu essayé d'utiliser des bibliothèques plus compactes ?

j'avoue n'avoir utilisé que les bibliothèques qui semblaient (?) fonctionner
pour répondre à ta question , non car je n'en connais pas d'autres
à quoi fais-tu référence par exemple ?

j'utilise :
Code:

1 2 3 4 5 6 #include <Adafruit_NeoPixel.h> #include <Wire.h> #include <Adafruit_Sensor.h> #include "Adafruit_VL53L0X.h" #include "DHT.h"
pascal

Citation:

Envoyé par cobra38

à quoi fais-tu référence par exemple ?

Rien de précis. C'était juste une idée.

En vrac

Bonjour,

tt et hh ne servent pas : -4 octets

n1 et n2 ne servent pas : -2 octets
vDHT et vVcc ne servent pas : -2 octets

measure1 et measure2 ne sont appelées que dans une fonction => pas globales

il est préférable de mettre valarm en argument de alarm() : -2 octets

Beaucoup de variables globales peuvent devenir locales notamment en utilisant des passages d'arguments et des valeurs de retour pour les fonctions.

Il y a des fonctions non appelées (par exemple CheckAlarm(), done() ).

Il y a des fonctions apparemment inutiles, par exemple alarmeOff() car toutes les leds sont éteintes au fur et à mesure.

Salutations

Bonjour Guesset

pardon pour la réponse tardive , je n'avais pas vu ton message
je prends bonne note pour toutes tes précisions et je vais faire le ménage
pour gagner quelques octets

merci encore d'avoir regardé mon petit problème

pascal

l'avantage des compilateurs modernes c'est que tout ce qui ne sert pas est viré pour vous et donc ne prend pas de place.

Donc c'est plus pour la forme et la beauté de la chose que l'on fait attention à ce genre de points

Les variables globales versus locales ou paramètres de fonctions - c'est généralement la bonne approche, éventuellement à réfléchir au cas par cas. Parfois (quand on veut s'assurer qu'il y a assez de mémoire pour que le code tourne sans dépendre d'allocation dynamique ou de la taille de la pile) c'est envisageable d'allouer la mémoire de manière statique.

merci Jay M de cette précision