Compteur Geiger Portable avec Arduino Nano : Construction Pas à Pas

Composants et fournitures

• 1x Arduino Nano R3
• 1x Kit compteur Geiger pré-assemblé
• 1x Écran OLED couleur 0,96" 96x64
• 1x Carte de charge micro USB pour batterie 18650
• 1x Batterie Li-ion 18650 3,7V 4000mAh protégée rechargeable
• 1x Transistor BC547
• 1x Buzzer 12mm
• 1x Résistance 1 kΩ

Outils et machines nécessaires

• Imprimante 3D (générique)

Applications et services en ligne

• Autodesk Fusion 360 (conception 3D)
• Arduino IDE
• CURA (trancheur impression 3D)
• ClickCharts (diagrammes)
• EasyEDA (conception PCB)
• Fritzing (schémas)

À propos de ce projet

Ce projet a démarré après l'achat d'un kit compteur Geiger pré-assemblé sur Banggood.

L'idée était de mettre ce kit dans un boîtier imprimé en 3D pour que l'ensemble fonctionne comme un compteur Geiger portable. Le résultat final est montré ci-dessous :

Étape 1 : Conception du Système

La conception du compteur Geiger portable est montrée dans le diagramme ci-dessous :

Le compteur Geiger est équipé d'un écran OLED couleur 0,96 pouce, qui informe l'utilisateur sur le CPM mesuré (mesure du taux de détection d'événements d'ionisation par minute) ainsi que sur l'équivalent de dose calculé en µSv/h en utilisant un facteur simple de 151 trouvé dans la littérature pour le type de tube Geiger-Müller (GM) utilisé.

Voir aussi Wikipédia : https://en.wikipedia.org/wiki/Counts_per_minute

En fait, le CPM affiché est le résultat d'un calcul des comptages sur une minute, en mesurant les comptages par seconde (CPS) et en stockant ces mesures dans un tableau couvrant les 10 dernières secondes. Le nombre total de comptages sur cette période de 10 secondes est multiplié par 6 pour obtenir la valeur CPM.

Le nombre de comptages sur la dernière seconde est utilisé pour afficher le nombre momentané de mesures via un graphique à barres sur l'écran OLED. Cela est utile en cas de taux de comptage élevé, ou lors de changements rapides du taux de comptage quand le compteur portable est déplacé au-dessus d'une source radioactive.

Le compteur Geiger est alimenté par une batterie Li-ion type 18650, rechargeable via une prise micro-USB. Le port USB de l'Arduino Nano est aussi accessible pour les mises à jour logicielles. Un buzzer supplémentaire est connecté à la carte du compteur Geiger pour amplifier le son des ionisations dans le tube GM.

Toute l'électronique du compteur Geiger est intégrée dans le boîtier imprimé en 3D :

L'écran OLED est placé dans une boîte séparée sur le dessus du compteur Geiger :

La version entièrement assemblée :

Étape 2 : Assemblage du Compteur Geiger

Les matériaux suivants sont utilisés :

• Arduino NANO 1 - https://store.arduino.cc/arduino-nano
• Kit Compteur Geiger 1 - Lien Banggood
• Écran OLED couleur 0,96" 96x64 1 - Lien Banggood
• Carte de charge micro USB batterie 18650 1 - Lien Banggood
• Batterie Li-ion 3,7V 4000mAh protégée 18650 1 - Lien Banggood
• Transistor BC547 1
• Buzzer 12mm 1
• Résistance 1 kΩ 1

La Conception Électronique

Le schéma électronique du kit compteur Geiger est montré dans le diagramme suivant :

Le schéma du montage complet du compteur Geiger est le suivant :

L'alimentation 5V est fournie par une batterie Li-Ion rechargeable placée dans une carte de charge micro USB. Le 3,3V pour l'écran OLED est prélevé sur cette carte.

Le montage sur breadboard utilisé pour les tests et le développement logiciel avec l'ARDUINO IDE est montré dans les images suivantes :

Assemblage Mécanique et Électrique

L'assemblage de toutes les pièces mécaniques et électroniques est montré dans les images ci-dessous :

Notez que le compteur Geiger portable n'a aucune connexion par câble externe.

Pour charger la batterie Li-ion 3,7V, il y a une ouverture séparée dans le boîtier pour connecter temporairement une prise micro USB.

Une connexion mini USB supplémentaire est disponible pour les mises à jour logicielles de l'Arduino Nano.

Étape 3 : La Conception Logicielle

Le organigramme suivant montre la conception logicielle générale du Compteur Geiger :

Les vues sur l'écran OLED 0,96" sont :

Le sketch Arduino complet est listé ci-dessous :

Code

Geiger_Counter.ino (Arduino)

/********* Ce projet a été développé et produit par Pierre Pennings (Décembre 2019), Ce projet concerne la fabrication d'un compteur Geiger portable utilisant un kit compteur Geiger pré-assemblé, dans un détecteur de radiations portable imprimé en 3D. Le kit est connecté à un Arduino Nano qui compte le nombre d'impulsions du tube Geiger/Muller sur une période de 10 secondes et affiche ensuite le CPM moyen (Comptages Par Minute) sur un écran OLED couleur 96x64. Le CPM mesuré est également affiché en micro Sievert par Heure (avec un facteur de conversion simple de 151). L'écran OLED affiche aussi la quantité momentanée d'impulsions mesurées (par seconde) et affiche les mesures sous forme de barre rouge mobile sur l'écran. Le boîtier imprimé en 3D contient aussi la batterie Lithium-Ion 18650 (rechargeable) qui fournit l'alimentation 5V à l'Arduino Nano ainsi qu'au kit compteur Geiger et 3,3V pour l'écran OLED. Un interrupteur marche/arrêt et un buzzer externe complètent le détecteur. À la mise sous tension, le niveau de charge de la batterie 18650 est affiché sur l'écran couleur. Ce code est sous licence GPL3+. *********/

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1331.h>
#include <SPI.h>

// Connexions pour l'écran OLED
#define sclk 13 // SCL (fil bleu)
#define mosi 11 // SDA (fil blanc)
#define cs 10   // CS (fil gris)
#define rst 9   // RES (fil vert)
#define dc 8    // DC (fil jaune)

#define LOGtime 1000 // Temps de journalisation en millisecondes (1 seconde)
#define Minute 60000 // Période de 1 minute pour calculer les valeurs CPM
#define show endWrite
#define clear() fillScreen(0)

// Définitions des couleurs
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF

Adafruit_SSD1331 display = Adafruit_SSD1331(cs, dc, rst);

int Counts = 0; // variable contenant le nombre d'événements tube GM dans LOGtime
unsigned long previousMillis = 0; // variable pour stocker le temps précédent
int AVGCPM = 0; // variable contenant la moyenne glissante du nombre de comptages sur une fenêtre mobile fixe
int TenSecCPM = 0;
int units = 0;
int tens = 0;
int hundreds = 0;
int thousands = 0;
float Sievert = 0;
int COUNTS[10]; // tableau pour stocker les quantités d'impulsions mesurées en 10 périodes consécutives de 1 seconde
int t = 0;

////////////////////// Le code setup qui suit s'exécute une fois après "Power On" ou après un RESET ///////////////////
void setup() {
  Serial.begin(115200);
  display.begin();
  display.fillScreen(BLACK);

  float Battery = analogRead(A3); // (fil orange)
  float BattPerc = 100 * (Battery / 770);
  //Serial.print("battery value = "); Serial.println (Battery);
  //Serial.print("battery percentage = "); Serial.println (BattPerc);

  display.setCursor(4,4);
  display.setTextSize(2);
  display.setTextColor(MAGENTA);
  display.println("Batterie");
  display.setCursor(4,24);
  display.print(int(BattPerc)); display.print("."); display.print(int((10*BattPerc)-(10*int(BattPerc)))); display.print(" %");
  delay(3000);
  display.fillScreen(BLACK);

  for(int x = 0; x < 10 ; x++) { // met toutes les données du tableau COUNTS à 0 (positions 0 à 9)
    COUNTS[x] = 0; // 10 positions couvrant une période de 10 secondes
  }

  attachInterrupt(0, IMPULSE, FALLING); // définit l'interruption externe sur pin D2/INT0 pour démarrer la routine IMPULSE (fil vert)

  display.drawRect(0,0,96,64,WHITE);
  display.setCursor(4,4);
  display.setTextColor(RED);
  display.setTextSize(2);
  display.print("CPM");
  display.setCursor(50,4);
  display.setTextSize(1);
  display.print("10 sec");
  display.setCursor(50,12);
  display.print("window");

  display.setCursor(4,38);
  display.setTextSize(1);
  display.setTextColor(GREEN);
  display.print("uSv/hr");

  display.drawRect(0,48, 96, 16, YELLOW);
}

//////////////////////// Le code loop qui suit s'exécute répétitivement jusqu'à "Power Off" ou un RESET ///////////
void loop() {
  unsigned long currentMillis = millis();
  if(currentMillis - previousMillis > LOGtime)
  {
    previousMillis = currentMillis;
    COUNTS[t] = Counts;
    for (int y = 0; y < 10 ; y++) { // additionne toutes les données du tableau COUNTS
      TenSecCPM = TenSecCPM + COUNTS[y]; // et calcule la moyenne glissante CPM sur une période de 10 secondes
    }
    AVGCPM = 6 * TenSecCPM;
    TenSecCPM = 0;
    t++;
    if (t > 9) { t = 0; }

    //Serial.print("COUNTS "); Serial.print(t); Serial.print(" = "); Serial.println(COUNTS[t]);
    display.fillRect(4,20,90,17,BLACK); // efface le champ valeur CPM sur l'affichage
    display.setCursor(4,20);
    display.setTextColor(RED);
    display.setTextSize(2);
    display.println(AVGCPM);
    //Serial.print("AVGCPM = "); Serial.print(AVGCPM); //Serial.print(" CPM = "); Serial.println(CPM);

    display.fillRect(45,38,50,10,BLACK); // efface le champ valeur uSv/Hr sur l'affichage
    display.setCursor(45,38);
    display.setTextColor(GREEN);
    display.setTextSize(1);

    Sievert = (AVGCPM / 151.0); //Serial.print(" Sievert = "); Serial.println(Sievert);
    units = int(Sievert); //Serial.print("units = "); Serial.println(units);
    tens = int((10*Sievert) - (10*units)); //Serial.print("tens = "); Serial.println(tens);
    hundreds = int((100*Sievert) - (100*units) - (10*tens)); //Serial.print("hundreds = "); Serial.println(hundreds);
    thousands = int((1000*Sievert) - (1000*units) - (100*tens) - (10*hundreds)); //Serial.print("thousands = "); Serial.println(thousands);
    display.print(units); display.print("."); display.print(tens); display.print(hundreds); display.println(thousands);

    display.fillRect(1,49,94,14,BLACK); // efface le champ indicateur CPM sur l'affichage
    display.fillRect(1,49,Counts,14,RED); // remplit le champ indicateur CPM sur l'affichage

    Counts = 0;
  }
}
////////////////// FIN DE BOUCLE ////////////////////////////////////

///////////////////////////////// Fonction pour compter le nombre d'impulsions du kit compteur Geiger
void IMPULSE() {
  Counts++;
}

La partie la plus importante du sketch est la fonction d'interruption appelée lorsqu'une impulsion sur le tube GM du compteur Geiger est mesurée et déclenche la sortie INT du compteur Geiger (en la mettant à LOW pendant une courte période). Le signal INT est connecté à la pin D2 (la broche d'interruption externe INT0 de l'Arduino Nano) :

attachInterrupt(0, IMPULSE, FALLING);

Le signal INT démarre la routine d'interruption IMPULSE() pour incrémenter Counts de 1 :

void IMPULSE() { Counts++; }

Après l'écoulement de 1000 millisecondes :

• l'entier Counts est remis à 0
• le tableau COUNTS[] est rempli avec le nombre de comptages mesurés pendant les 1000 dernières millisecondes
• le nombre total de comptages sur les 10 dernières secondes est calculé en additionnant tous les nombres du tableau COUNTS[] et multiplié par 6 pour présenter la valeur CPM sur l'écran.
• L'équivalent de dose exprimé en µSv/h est calculé en divisant la valeur CPM par 151 (valeur trouvée dans la littérature).
• Sur l'écran OLED couleur, une barre rouge est affichée basée sur la valeur de Counts de la seconde écoulée, présentant en fait la valeur CPS (Comptages Par Seconde).

Le sketch Arduino complet pour le compteur Geiger comprend environ 150 lignes de code. La liste complète est incluse dans ce tutoriel, le code ARDUINO (voir chapitre 9) est fourni avec une quantité ample de commentaires.

Pièces imprimées 3D

• Boîtier pour écran OLED 0,96" : display_geiger_rev04_v2_bsLHSDvTUU.3mf
• Boîtier principal (haut et bas) conçu avec Fusion 360 : geiger_counter_housing_top__bottom_rev04_v1_cvCIwkO13j.obj (fichier STL 3D)

Schémas

Ce diagramme montre la configuration de l'électronique :