Cadencement d'une boucle

[2 terium]

Bonjour,

Debutant en arduino et n'ayant rien trouver de compréhensible a mon niveau, je vous demande,

Est ce que quelqu'un, pourrait m'expliquer simplement comment on fait pour imposer une cadence a une boucle de programmation (arduino) svp? (IDE 0023 au cas ou)

Je m'explique:

je veux réaliser des prises de températures a intervalle fixe pour remplir un tableau et faire une moyenne.

Mais je dois d'abord activé une broche numérique pour rendre passant un transistor fermant mon diviseur de tension (100K + NTC 100K).

L’idée:

Pendant 2 ou 5 ou Nsecondes,

activer ma broche a intervalle régulier pendant environ 10ms, lire, et l’éteindre pour la réactiver à la lecture suivante.

Chaque lecture dois être stocker dans un tableau et à la fin, faire une moyenne pour l'impression serie.

Je compte sur l'utilisation de millis() mais je n'arrive pas a paramétrer comme je voudrais. je ne peut plus utiliser les attachinterrupt (deja pris pour Vitesse et RPM). DONC PAS DE DELAY EN PROG...

J'ai regarder du cote de smoothing, mais je n'arrive pas non plus à mettre une fonction qui cadence.

J'ai donc établie un code un peu enfantin mais qui a l'air d’être sur la bonne voix (enfin au moins je vois des coupures d'activation pour le transistor mais j'ai pas l'impression qui suis le rythme que je veut) (aie, les pros vont m’écorche vif....).

Au final, j'aimerai pouvoir passer dans une boucle for afin de remplir mon tableau et cadencer chaque i+1 par (Nseconde/Nbcase tableau).

Le code actuel:

/*lecture de temperature en 3.3V Aref sur NTC 100K + R100K */
unsigned long refTemps=0;                                         
unsigned long interval=200;
unsigned long mesure=5;

int ThermistorPin = A0; //pin analogique pour sonde NTC100K
int ActivationSonde = 12; //pin d'activation du circuit de prise temperature sur broche D12
//int Vo;
float R1 = 10000;
float logR2, R2, T;
float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;


const int NombreDeLecture = 10;
int Lecture[NombreDeLecture];
int Total=0;
int Moyenne=0; //remplace la variable Vo

void setup() {

Serial.begin(9600);
analogReference(EXTERNAL);
pinMode(12,OUTPUT);
pinMode(0,INPUT);
digitalWrite(12,LOW);

//for (int thisReading = 0; thisReading < NombreDeLecture ; thisReading++)
   // Lecture[thisReading] = 0;  

}

void loop(){     

  digitalWrite(12,HIGH);
  Lecture[0]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH); 
  Lecture[1]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH);
  Lecture[2]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH);
  Lecture[3]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH);
  Lecture[4]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
 
  digitalWrite(12,HIGH);
  Lecture[5]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH);
  Lecture[6]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH);
  Lecture[7]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH);
  Lecture[8]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval;
  
  digitalWrite(12,HIGH);
  Lecture[9]=analogRead(ThermistorPin);
  refTemps=millis() ;
  millis()-refTemps>=mesure;
  digitalWrite(12,LOW); 
  refTemps=millis() ;
  millis()-refTemps>=interval; 
  
 
  
  Total =  Lecture[0] + Lecture[1] + Lecture[2] + Lecture[3]
  + Lecture[4] + Lecture[5] + Lecture[6] + Lecture[7]
  + Lecture[8] + Lecture[9];
  
  Moyenne = Total/NombreDeLecture;
  
  //Vo = analogRead(ThermistorPin); //Vo a remplacer par Moyenne
  //R2 = R1 * (1023.0 / (float)Vo - 1.0); //equation d'origine
  R2 = R1 * (1023.0 / (float)Moyenne - 1.0);
  logR2 = log(R2);
  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
  T = T - 273.15;
 // T = (T * 9.0)/ 5.0 + 32.0; // pour affichage en degree Farhenheit
  
  refTemps=millis();
   
  
  //Pour affichage moniteur serie
  Serial.print("millis");
  Serial.print(millis());
  Serial.println (Lecture[0]);
  Serial.println (Lecture[1]);
  Serial.println (Lecture[2]);
  Serial.println (Lecture[3]);
  Serial.println (Lecture[4]);
  Serial.println (Lecture[5]);
  Serial.println (Lecture[6]);
  Serial.println (Lecture[7]);
  Serial.println (Lecture[8]);
  Serial.println (Lecture[9]);
  Serial.print("Total: "); 
  Serial.println(Total);
  Serial.print("Moyenne: "); 
  Serial.println(Moyenne);
  Serial.print("Temperature: "); 
  Serial.print(T);
  Serial.println(" C"); 
  Serial.println();
 
 /*
 //sendTEMPToNextion();
  Serial.print("t3.txt=");
  Serial.print("\"");
  Serial.print(T);
  Serial.print("\"");
  Serial.write(0xff);
  Serial.write(0xff);
  Serial.write(0xff); */
  
  
}

Ce code n'imprime que 9 valeur du tableau??pkoi??

Est ce que ce que je veut faire est réalisable?
Sans bibliothèque ou truc tordu?


Merci d'avance pour votre compréhension et votre aide. le but étant surtout de comprendre comment piloter et cadencer une boucle de manière simple! (syntaxe? truc que j'ai pas piger??)

Cordialement.
-----

[invitef86a6203]

int i;
  refTemps=millis() ;
  for (i=0;i<10;i++) { 
  	digitalWrite(12,HIGH);
	Lecture[i]=analogRead(ThermistorPin);
	digitalWrite(12,LOW); 
        delay(10); // lecture tout les 10 ms	
		// METTRE LA bonne valeure
  }

  Total =0;
  for (i=0;i<10;i++)  Total +=   Lecture[i]; 
//
// calculs
//
  Moyenne = Total/NombreDeLecture;
  Serial.print("millis");
  Serial.println(refTemps);

  for (i=0;i<10;i++)  Serial.println (Lecture[i]);

/*
// si on a plus d'une chose à afficher
  for (i=0;i<10;i++)  {
            Serial.print (i * 10 );
            Serial.print ("ms ");
            Serial.println (Lecture[i]);
            }
*/

[2 terium]

Bonjour freepicbasic (PAT).

Le code ne marche pas cher moi. des que je rajoute millis() a la place du delay, la température va crescendo. pour rappel, je ne veut pas utiliser delay pour pas bloquer mes autres capteurs pour la suite.

je ne comprend pas pourquoi ça ne veut pas marcher... voila le nouveau code:
j'ai commenté les passage de millis car ne marche pas avec.

#define NUMSAMPLES 10

unsigned long refTemps=0;                                              
unsigned long interval=200;
unsigned long mesure=0;

int ThermistorPin = A0; //pin analogique pour sonde NTC100K
int ActivationSonde = 12; //pin d'activation du circuit de prise temperature sur broche D12
//int Vo;
float R1 = 10000;
float logR2, R2, T;
float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;   
 
int samples[NUMSAMPLES];
 
void setup() {
  
  Serial.begin(9600);
  analogReference(EXTERNAL);
  pinMode(12,OUTPUT);
  digitalWrite(12,LOW);
}
 
void loop() {
  uint8_t i;
  float Moyenne;
 
 // refTemps=millis();
  // take N samples in a row, with a slight delay
  for (i=0; i<NUMSAMPLES; i++) {
   
   digitalWrite(12,HIGH);
   samples[i] = analogRead(ThermistorPin); 
   digitalWrite(12,LOW);
   
   //millis()-refTemps>=interval;
   
 }
  
  
  
  // average all the samples out
  Moyenne = 0;
  for (i=0; i<=NUMSAMPLES; i++) {
     Moyenne += samples[i];
  }
  
 // if(i>=NUMSAMPLES){
   // i=0;}
  
    
  Moyenne /= NUMSAMPLES;
 
  
  
  //Vo = analogRead(ThermistorPin);
  //R2 = R1 * (1023.0 / (float)Vo - 1.0);
  R2 = R1 * (1023.0 / (float)Moyenne - 1.0);
  logR2 = log(R2);
  T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
  T = T - 273.15;
  // T = (T * 9.0)/ 5.0 + 32.0; // pour affichage en degree Farhenheit
 
 
  Serial.print ("Temperature:");
  Serial.print ( T);
  Serial.println ("C");
}

Si je met un delay (200) a la place de millis() j'ai bien les clignotements sur ma pin de base transistor mais la lecture commence a 45° puis 81° puis 0.00° sur tous le reste.

En gros, j'aimerai vraiment trouver comment on ralenti une incrémentation (apparemment la prise de mesure (HIGH;HOW passe sans trop de mal si pas de temps speciaux.)

mais le programme remplie tous le tableau en un seul loop g l'impression.. donc pas top.

le but serai de lire le capteur et remplir chaque case a temp+interval ==>i+1.

Mais je sèche grave et c'est un peu gonflant. pourtant jsuis sur c'est tous bête en vrai.

[invitef86a6203]

Je ne suis pas sur de comprendre vraiment ce que tu veux...
Je met un autre exemple

unsigned long interval=200;
long time;
int ptr=0;
#define NUMSAMPLES 10

void loop() { 
    time =millis();
    while (millis()< (time+interval) ) ;
    ReadTemp(ptr);
    ptr ++;
    if (ptr>NUMSAMPLES) ptr=0;
}

void ReadTemp(int n) {
   digitalWrite(12,HIGH);
   samples[n] = analogRead(ThermistorPin); 
   digitalWrite(12,LOW);

}

[A voir en vidéo sur Futura]

[2 terium]

Pat, je te remercie grandement de m'avoir apporter ton aide.

Je me suis dépatouiller avec ton deuxième morceau (boucle while) et là, sa a marché.

J'ai quand même eu un peu de mal a comprendre la mise en variable (int n) dans la fonction de lecture de la temp°.

Il a fallu que je créer un int i pour la somme et la moyenne..car je n'arriver pas a faire marcher en positionnant int n ailleurs.

Si je comprend bien, n et ptr sont lier par readTemp et samples..bref, je dois bosser encore! mais franchement ton coup de pouce, ça ma fais saisir des points important je pense.

je met le code final, si ça peut servir...

pont diviseur partant du 3.3v avec NTC100K - fil en A0 - Resistance 100K sur collecteur BC547 emetteur au GRD
D12 avec R4.7K a la base du transistor.

unsigned long interval=200;
unsigned long time;
int ptr=0;  
#define NUMSAMPLES 10 //nombre de lecture
int samples[NUMSAMPLES];
int ThermistorPin = A0; //pin analogique pour sonde NTC100K
//(int) ActivationSonde = 12; // pin digital D12
//float R1 = 10000;
//float logR2, R2, T;
//float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07; 



void setup() {
  
  Serial.begin(9600);
  analogReference(EXTERNAL);
  pinMode(0,INPUT);
  pinMode(12,OUTPUT);
  digitalWrite(12,LOW);
}


void loop() { 
  
 float Moyenne;
  
  
    time=millis();
    while (millis()< (time+interval) ) ;
    ReadTemp(ptr);
    ptr ++;
   /* Serial.print("ptr");
    Serial.print( ptr);
    Serial.println();
    Serial.println("samples[]");
    Serial.println(samples[0]);
    Serial.println(samples[1]);
    Serial.println(samples[2]);
    Serial.println(samples[3]);
    Serial.println(samples[4]);
    Serial.println(samples[5]);
    Serial.println(samples[6]);
    Serial.println(samples[7]);
    Serial.println(samples[8]);
    Serial.println(samples[9]);
    Serial.println();*/
    
    if (ptr>=NUMSAMPLES){
      
      Moyenne = 0;
      for (int i=0; i<NUMSAMPLES; i++) {
      Moyenne += samples[i];}
      
      Moyenne /= NUMSAMPLES;
  /*  Serial.print ("Moyenne");
      Serial.print (Moyenne);
      Serial.println(); */
      
      float R1 = 10000;
      float logR2, R2, T;
      float c1 = 1.009249522e-03, c2 = 2.378405444e-04, c3 = 2.019202697e-07;
      
      R2 = R1 * (1023.0 / (float)Moyenne - 1.0);
      logR2 = log(R2);
      T = (1.0 / (c1 + c2*logR2 + c3*logR2*logR2*logR2));
      T = T - 273.15;
      // T = (T * 9.0)/ 5.0 + 32.0; // pour affichage en degree Farhenheit
 
     /* 
      Serial.print ("Temperature:");
      Serial.print ( T);
      Serial.println ("C");     */
      
     
      //sendTEMPToNextion();
      Serial.print("t3.txt=");
      Serial.print("\"");
      Serial.print(T);
      Serial.print("\"");
      Serial.write(0xff);
      Serial.write(0xff);
      Serial.write(0xff); 
     
      time=millis();
      ptr=0;}
}
////partie fonction lecture smooth pilotee////
void ReadTemp(int n) {
  
   digitalWrite(12,HIGH);
   samples[n] = analogRead(ThermistorPin); //
   //Serial.println("samples[n]");
   //Serial.print(samples[n]);
   digitalWrite(12,LOW);

}

il envoi le tous sur un écran Nextion par serie.

Me reste plus qu'as comprendre pourquoi ton premier exemple ne passer pas..

Si quelqu'un vois comment encore l'optimiser, je prend!

Encore merci, Pat, pour le coup de patte...

[invitef86a6203]

Je vois que tu progresse vite, c est encourageant pour t'aider.

Apparemment tu as quelques soucis avec les variables globales et locales et les variables en paramètres.

Une variable globale est visible par toute les procédures elle est déclarée en dehors de toute les procédures, généralement en haut du programme.

Une variable locale est effacé à la sortie de la procédure.
Ou plutôt contient n'importe quoi à l'entrée car il s'agit de la pile.

Les variables paramètres sont des variables locales , la différence c'est quelle sont initialisés avant d'entrer.

MyProc(ptr);

void MyProc(int n) {n++; etc...}

La variable ptr qui est locale de loop ou globale sera copier dans la variable locame de MyProg.
On peut donc modifier n localement sans avoir modifié ptr.

Dans notre exemple ptr est globale on aurait pu l'utilisé directement si on n'y touchait pas.
Le fait de passer par n sécurise si on fait une modif par la suite.
du genre;
for (;n>0;n--) Serial.print .... // Dans ce cas n est modifié.

Il est conseillé d'éviter les globales autant que possibles car elles bloquent la mémoire.
Les locales sont empilé sur le stack et libèrent le stack à la sortie, donc si on appelle séquentiellement
des procédures on peu utiliser plus de mémoire que celle disponible, si elles était toute globale.