[Conseil] programmation compteur Geiger

Salut :slight_smile:

Et bien je me lance :

Je suis totalement débutant, mais autodidacte et je me lance dans la programmation d’un compteur Geiger dont voici les caractéristiques :

-harware :
*arduino uno
*lcd 20x4
*capteur Geiger SBT10-A
*platine geiger (impulsion de 5v propre à chaque désintégrations).
*bouton poussoir (control menu)
*inter (power, buzzer, vibreur, rétroéclairage LCD)
*buzzer
*vibreur
*led

Voici le fonctionnement :

-le capteur geiger via sa carte de contrôle envoi une impulsion (+5V) à l’arduino à chaque désintégration (peux aller jusqu’à 50k impulsions/secondes, mais la plage d’utilisation sera plutôt à 1600/’’).
Je me demande qu’elle serait la vitesse maximum d’échantillonnage de l’arduino ?

-affichage sur les 4 lignes de l’écran

X̅5s Bq Sv/h
X̅1’ Bq Sv/h
max Bq Sv/h
∑ Bq Sv

-programmer :
*moyenne impulsion sur 5s, + conversion en Sieverts
*moyenne impulsion sur 1‘, + conversion en Sieverts
*valeur maximale atteinte des impulsions, + conversion en Sieverts
*Compteur total des impulsions, + conversion en Sieverts

*buzzer (+ LED à éventuellement ajouter dans le prog si dessous et augmenter le délais de l’impulsion du programme sur le pin de la led pour qu’elle flash) : 1clic/désintegration.

*vibreur + alarme avec seuille réglable via un menu. Et là je ne vois pas comment ne pas ajouter une enclume au programme :frowning:

Une fois terminé, j’aimerai que la carte arduino compte toutes les impulsions, mais vue qu’il n’y a qu’un seul processeur, je ne vois pas comment passer à côté de plusieurs infos envoyées par la carte du Geiger lorsque le processeur fait autre chose (affichage, calcul…). Du coup je me demande s’il ne faudrait pas deux arduino :
-un qui fait seulement le comptage et qui l’envoie au second qui ferait tout le reste.

De par cette même logique (qui est peut-être fausse vue que je suis débutant), j’ai choisi de contrôler l’activation ou l’arrêt des buzzer, vibreur, led et retro éclairage lcd par action mécanique plutôt que d’allonger le programme.

**** Mes problèmes pour le moment :
-j’ai bien réussi à créer des caractères spéciaux, les injecter dans le LCD, mais par la suite, quelque soit le programme, le LCD bug de façon aléatoire et affiche par moment n’importe quoi. Du coup je n’ai pas pollué mon écran 20x4 avec les nouveaux caractères.
-je ne vois pas comment programmer un menu pour l’alarme qui ne soit as lourd.

Je suis preneur de tout conseil pour alléger mon programme et faire en sorte que la priorité soit sur le comptage et non l’affichage.

Merci à vous :slight_smile:

PS : des portions de la programmation en cours sont en pièce jointe

ok_code_buzer_et_led_CPM.ino (626 Bytes)

test_cr_ation_caract_re.ino (1.84 KB)

beta_code_affichage_micro_siever_et_cpm_ok_15_02.ino (8.57 KB)

Pour l’affichage, je suis totalement incompétent…

Pour ce qui est du comptage des impulsions et pour faire un compteur, il y a deux solutions:

  • A - on compte le nombre de désintégration pendant une seconde, puis on affiche. Il n’est pas forcément nécessaire de compter TOUTES les impulsions.
  • B - on compte toutes les impulsions en dissociant deux tâches, un peut comme tu le souhaites. Je m’intéresse à la fonction millis() que je simplifie un peu. Tu n’utilises pas forcément millis() dans ce que tu fais (ton programme principal), mais toutes les ms, Le microcontrôleur laisse provisoirement ton programme pour compter une milliseconde de plus. Ton code ne se soucie pas du comptage. Le comptage se fait régulièrement car il est prioritaire. Au lieu de faire une fonction d’interruption qui compte les ms, tu fais une fonction d’interruption qui compte les impulsions.

Si tu mets deux cartes, l’une qui compte les impulsions et l’autre qui affiche, que va-t-il se passer quand la première doit donner le résultat à la deuxième? Elle ne sera plus libre de compter vu qu’elle devra préparer et envoyer des données.

Faire la fonction d’interruption n’est pas très compliquée, tu aura de l’aide pour cela.

Je me demande qu’elle serait la vitesse maximum d’échantillonnage de l’arduino ?

Il vaut mieux demander aux autres qu’à toi même, tu auras une meilleure réponse
Une fonction d’interruption pour faire un comptage simple dure environ 5µs. Si les impulsions étaient régulières, on pourrait en compter 200000 par secondes. Les limitation sont en réalité:

  • si une première impulsion arrive, on peut en avoir une qui suit, on finit de traiter la première, puis on fait la seconde car on a un indicateur qui informe d’une nouvelle impulsion. Mais si une troisième arrive, comme l’indicateur ne peut mémoriser que “il y en a une en attente” ou “il n’y en a pas en attente”, on perdra une impulsion. On peut donc avoir une impulsion à T, puis une impulsion à T+1µs, mais la suivante doit attendre environ 5µs pour que la première demande soit terminée. On va dire 5µs entre impulsion, mais de temps en temps 1µs passe
  • si on laisse le timer 0 en route (pour laisser millis, delay fonctionner), on a un trou d’environ 8µs pendant lequel on peut mettre en attente qu’une seule impulsion. Donc si les impulsions arrivent toutes les 8µs, on en perd une chaque ms. Une solution est de désactiver l’horloge système, mais tu aura alors du mal pour compter pendant une 1s. Cela peut être négligeable si il est rare que deux impulsions arrivent à moins de 8µs d’intervalle et pendant l’interruption d’horloge.

Merci pour la réponse et pour la touche d'humour :slight_smile:

C'est une très bonne idée de faire des cycles de comptage de 5 secondes puis basculer sur le reste du programme.
Je vais chercher comment ça fonctionne.

Quelqu'un aurait il une idée pour un menu pas trop lourds et pour mon problème de bug LCD lors de la création de caractère?

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.