Parasites sur entrée interruption Arduino DUE

Bonjour, dans le cadre du projet:

A l’origine j’avais un attiny45 compter les impulsions provenant d’un capteur sur le compteur d’eau à raison d’une impulsion par litre, et la capacité max de mon compteur d’eau est de 1,5m3/h soit un max de 25l/min. J’avais mis en place un système d’anti rebond d’une seconde. Les infos était récupéré par la DUE via le Bus I2C.

Dans le but de simplifié le montage et la programmation, j’ai supprimé l’attiny45 dédiè au comptage des impulsions et son travail intégré à la carte DUE.

Mise en service à 18h00 hier soir, effectué quelques essais tout semble fonctionner correctement.
Ce matin l’horreur en découvrant l’historique compteur d’eau (pièce jointe) .
A partir de 21H10, ma carte m’a presque 1 interruption / seconde.

Je précise qu’il n’y a aucun filtrage hardware, et que le compteur d’impulsion est de typye collecteur ouvert.

Plan câblage arduino en piece jointe

Voici l’extrait du code de la carte DUE:

// variables pour compteur_eau
float metrecubesfloat = 0.0;
float Debit_Eau = 0.0;
int pin_compteur_eau = 2;
unsigned long last_interrupt_time = 0;




void setup()
{
  pinMode(pin_compteur_eau, INPUT);
  digitalWrite(pin_compteur_eau, HIGH); //use the internal pullup resistor
  attachInterrupt(digitalPinToInterrupt(pin_compteur_eau), ISR_EAU, RISING);
}

void ISR_EAU()
{
  unsigned long temps_entre_pulses;
  unsigned long interrupt_time = millis();
  if (interrupt_time - last_interrupt_time > 1000) {//filtre anti-rebond à 1s
    metrecubesfloat = metrecubesfloat + 0.001;
    temps_entre_pulses = (millis() - last_interrupt_time);
    //  Serial.print ("temps_entre_pulses: ");
    //  Serial.println (temps_entre_pulses);
    Debit_Eau = (1000.0 / (float)temps_entre_pulses) * 60.0;
    // Serial.print ("Debit_Eau: ");
    // Serial.println (Debit_Eau);
    last_interrupt_time = interrupt_time;
  }
}

Problème similaire à rjnc38:

Si c'est une sortie collecteur ouvert, il manque une résistance de pullup dans le montage.

Dans une ISR les variables globales utilisées doivent être déclarées 'volatile'.

volatile unsigned long last_interrupt_time = 0;

Roger.

Une remarque:

Si tu n'as pas besoin que 'last_interrupt_time' soit globale, déclare la 'static' dans l'ISR.

Si c'est une sortie collecteur ouvert, il manque une résistance de pullup dans le montage.

Bonjour fdufnews et bilbo83, merci de vos réponses oui j'ai bêtement recopier un bout de code trouvé:

digitalWrite(pin_compteur_eau, HIGH); //use the internal pullup resistor

alors qu'il aurait fallu utilisé:

pinMode(pin_compteur_eau,INPUT_PULLUP);

Je suis vraiment un boulet sur ce coup ... finalement j'ai mis la résistance de pullup en Hard !

Quand aux déclarations variables dans les ISR je ne savais pas, car très peu utilisé chez moi.

Bonjour, j’ai donc suivi vos conseils, pour les variables , la résistance de pullup. Et j’ai de nouveau eu mon compteur d’eau qui s’est emballé comme un fou. Mais j’ai trouvé la source du problème :slight_smile: car j’avais la connexion Ethernet relié à l’arduino. Sur l’arduino l’alimentation externe 9V. Et c’est l’osque j’ai débranche la prise USB, que le compteur s’est emballé.

Donc j’ai réalisé plusieurs essais avec l’alim externe 9V et un chargeur USB.

Le resultat:

avec l’alimentation 9V =>le compteur s’emballe; interruptions toutes les secondes.

avec le chargeur USB => fonctionnement correct.

Amis électroniciens, Avez vous déjà rencontrer ce type de phénomènes?

En pièce jointe les photos des 2 chargeurs

ptitnitro62000:
avec l’alimentation 9V =>le compteur s'emballe; interruptions toutes les secondes.
avec le chargeur USB => fonctionnement correct.

depuis un certain temps je met en doute le step-down de la carte qui a été implanté la ou il y avait de la place sans se soucier des pb que cela pouvait induire

depuis un certain temps je met en doute le step-down de la carte qui a été implanté la ou il y avait de la place sans se soucier des pb que cela pouvait induire

Cela s'appelle une arduinerie.
Malheureusement je pense que très probablement tu as raison.

J’essaie de trouver des éléments de réponse sur Arduino Forum > Products > Arduino Due .

Mais je trouve pas grand choses.... :confused:

tu peux mettre en oeuvre le debounce que j'ai décrit dans mon post, mais la seule restriction que j'ai trouvé c'est que le diviseur (= temps du filtre) s'applique au port entier donc pas question de faire un debounce "adapté" a chaque entrée (il reste quand même le choix d'appliquer ou pas le filtre pour chaque entrée)
une autre solution serait de mettre un step-down externe et d'alimenter le DUE par la broche 5v (ce que je fais sur les MEGA) mais j'ai pas osé faire l'essai sur le DUE....

Va aussi faire un tour sur l’autre arduino www.arduino.org , dès en recoupant des informations incomplètes on peut avancer.

Bonjour, toujours la même galère, même avec la carte alimenté via le port USB, j’ai environ une vingtaine d’interruption en trop!!! que ça soit avec une carte mega ou une carte DUE.

Mais cette fois j’ai un coupable! il s’agit de ma clim réversible! qui a l’air de foutre pas mal de bruit sur le réseau. Idem en mentant une alim bien filtré!.. rien à faire …

Donc pour la petite histoire je suis repasse avec un attiny 85 pour compter les impulsions provenant du capteur et là pas de problème! (l’attiny semble être immunisé aux bruits ).

Mais je veux pas rester sur un échec, je voudrais mettre en place un système, qui fait la différence entre une perturbation extérieur" (ici la clim) et mon signal provenant du capteur.

Mon capteur est à collecteur ouvert, j’utilise une résistance de PULL-UP, à chaque litre prélevé, le signal sur l’entrée interruption passe à l’état bas pendant une certaine durée. J’utilise donc la détection de front descendant + un debounce à 1s.

Mon idée serait de mesuré le temps du signal à l’état bas. (je pense que se temps est identique quel que soit le débit) , ce qui permettrait d’obtenir une 'signature du capteur"

Là où ça se corse c’est pour la mise en oeuvre… je pense utilisé 2 entre interruptions
1 en Falling et 1 en Rising avec les filtres de debounce, sachant que c 'est le 1 front descendant qui doit être pris en compte et le dernier front montant.

Je vais essais de bosser là dessus, mais si vous avez des idées …

En pièce jointe un petit chronogramme.

1s de debounce semble énorme, un compteur en 20/27 peut débiter 5m3/h soit 83l/mn donc plus d'une imulsion par s
as tu essayé un anti-rebond externe avec 2 NAND triggées (4093) c'est ce que j'utilise sur un anémomêtre

Salut rjnc le problème ne viens pas des rebonds capteur, c est des parasites environnant. car sans capteur relié, avec uniquement la pull-up , j'ai quand meme des interruption ! ( au minimumun 20 sur 24 H)

cette clim réversible, fait de grosse perturbation! mes ampoules incandescent faiblissent à chaque mise en route !!!

1s de debounce semble énorme, un compteur en 20/27 peut débiter 5m3/h soit 83l/mn donc plus d'une imulsion par s

t’inquiète pas pour ça moi mon compteur est limité à 1,5 m3/h soit 25l/min. J'ai deja realisé des essais au grand max j'arrive à 29 l/min . d'ou ce debounce de 1 s...

eut être que les pull-up internes sont trop importantes dans ce cas , j'avais vu qu'une résistance externe plus faible améliorait les choses
tu peux peut être filtrer le 5v de l'arduino avec 100µF(voir 220) et 100nF

eut être que les pull-up internes sont trop importantes dans ce cas , j'avais vu qu'une résistance externe plus faible améliorait les choses
tu peux peut être filtrer le 5v de l'arduino avec 100µF(voir 220) et 100nF

Je suis en pull-up externe et j'ai mis en place des condos (100µF) pour filtré le 5V sans resultat! (j'ai pas de condos en nano)

Apres quelques mesures, le capteur qui est à collecteur ouvert , se ferme pendant 65 ms à chaque litre débité et de plus celui ci n’as aucun effet de rebond visible (enfin je met quand même le debounce)

Voila j’ai écrit quelque chose qui fonctionne à merveille :slight_smile: j’espère que ça va contrer ces p**** de perturbation electrique:

int pin_compteur_eau1 = 2;
int pin_compteur_eau2 = 3;
volatile unsigned long compteur= 0;
volatile unsigned long last_interrupt_timeFM = 0;
volatile unsigned long interrupt_timeFM = 0;
volatile unsigned long temps_entre_FD_FM;
volatile unsigned long last_interrupt_timeFD = 0;
volatile unsigned long interrupt_timeFD = 0;
volatile int FD_valide = 0;



void setup()
{
  Serial.begin(9600);
  Serial.println(F(" > Activation ISR du Compteur d'eau"));
  pinMode(pin_compteur_eau1, INPUT);
  pinMode(pin_compteur_eau2, INPUT);
  attachInterrupt(digitalPinToInterrupt(pin_compteur_eau1), ISR_Front_descendant, FALLING);
  attachInterrupt(digitalPinToInterrupt(pin_compteur_eau2), ISR_Front_montant, RISING);
}



void loop()                     
{
   Serial.print("compteur:");
   noInterrupts();
   Serial.println (compteur);
   interrupts();
   delay(1000);
}



void ISR_Front_descendant()
{
  interrupt_timeFD = millis();
  if (interrupt_timeFD - last_interrupt_timeFD > 2000) {
   // Serial.println ("ISR_Front_descendant");
    last_interrupt_timeFD = interrupt_timeFD;
    FD_valide = 1;
  }
}

void ISR_Front_montant()
{
  if (FD_valide == 1) {
    interrupt_timeFM = millis();
    if ((interrupt_timeFM - last_interrupt_timeFD > 60) && (interrupt_timeFM - last_interrupt_timeFD < 70)) {
      temps_entre_FD_FM = (millis() - last_interrupt_timeFD);
     // Serial.println ("ISR_Front_montant");
     // Serial.print ("temps_entre_FD_FM : ");
     // Serial.println (temps_entre_FD_FM);
      // last_interrupt_timeFM = interrupt_timeFM;
      FD_valide = 0;
      compteur++;
    }
    if ((interrupt_timeFM - last_interrupt_timeFD < 60) || (interrupt_timeFM - last_interrupt_timeFD > 70)) { //parasite electrique
      FD_valide = 0;
    }
  }
}

Il me reste plus qu’a remettre tout ça en place dans mon projet et validé son fonctionnement durant une période de 24H.

Après 212 litres débité pas un de plus et pas un de moins sur une période d'environ 20 H et correspondant exactement à la consommation relevé au compteur! je peux enfin validé le fonctionnement sur la carte Mega :slight_smile:

Avec ce filtrage de front montant et descendant + verif du temps à l’état bas du signal, les perturbations ne sont plus comptés.

Pour le moment j'utilise du coup 2 entrées interruptions... mais bon je suis trop content d'avoir réussi à résoudre ce problème!

Merci à tous pour votre aide et vos suggestions!