Handheld-Geigerzähler mit Arduino Nano

Notwendige Werkzeuge und Maschinen

3D-Drucker (generisch)

Apps und Onlinedienste

	Autodesk Fusion 360
	Arduino-IDE
	CURA
	ClickCharts
	EasyEDA
	Fritzing

Über dieses Projekt

Dieses Projekt begann, nachdem ich ein fertiges Geigerzähler-Kit von Banggood gekauft hatte.

Die Idee war, dieses Kit in ein 3D-gedrucktes Gehäuse zu stecken, damit das komplette funktionierende Geigerzähler-Set in der Hand gehalten werden kann. Das Endergebnis ist unten dargestellt:

Schritt 1:Systemdesign

Das Design des handgehaltenen Geigerzählers ist in der folgenden Abbildung dargestellt:

Der Geigerzähler ist mit einem 0,96 Zoll großen OLED-Farbdisplay ausgestattet, das den Benutzer über den gemessenen CPM (Maß der Detektionsrate von Ionisationsereignissen pro Minute) sowie die (berechnete) Äquivalentdosis in µSv/h mit einem einfachen Faktor informiert von 151, die in der Literatur für den verwendeten Geiger-Müller (GM)-Rohrtyp zu finden sind.

Siehe auch Wikipedia:https://en.wikipedia.org/wiki/Counts_per_minute

Tatsächlich ist der angezeigte CPM das Ergebnis einer Berechnung der Zählungen für eine Minute, indem die Zählungen pro Sekunde (CPS) gemessen und diese Messwerte in einem Array gespeichert werden, das den Zeitraum der letzten zehn Sekunden abdeckt. Die Gesamtzahl der Zählungen in den letzten 10 Sekunden wird mit 6 multipliziert, um den CPM-Wert zu erhalten.

Die Anzahl der Zählungen in der letzten Sekunde wird verwendet, um die momentane Anzahl der Messungen durch ein Balkendiagramm auf dem OLED-Display anzuzeigen. Dies ist nützlich bei hohen Zählraten oder wenn schnelle Änderungen der Zählrate auftreten, wenn der Handzähler über eine Strahlungsquelle bewegt wird.

Der Geigerzähler wird von einem Li-Ionen-Akku Typ 18650 betrieben, der über einen Micro-USB-Stecker aufgeladen werden kann. Der Arduino Nano USB-Port ist auch für Softwareänderungen zugänglich. Ein zusätzlicher Summer ist an die Geigerzählerplatine angeschlossen, um den Klang der Ionisationen in der GM-Röhre zu verstärken.

Die gesamte Elektronik für den Geigerzähler ist im 3D-gedruckten Gehäuse verbaut:

Das OLED-Display befindet sich in einer separaten Box oben auf dem Geigerzähler:

Die fertig montierte Version:

Schritt 2:Herstellen der Geigerzähler-Baugruppe

Folgende Materialien werden verwendet:

• Arduino NANO 1 https://store.arduino.cc/arduino-nano
• Geigerzähler-Kit 1 https://de.banggood.com/Assembled-DIY-Geiger-Counter-Kit-Module-Miller-Tube-GM-Tube-Nuclear-Radiation-Detector-p-1136883.html?rmmds =search&cur_warehouse=CN
• 0,96" OLED-Farbdisplay 96 * 64 1 https://www.banggood.com/0_95-Inch-7pin-Full-Color-65K-Color-SSD1331-SPI-OLED-Display-For-Arduino-p- 1068167.html?rmmds=search&cur_warehouse=CN
• Micro-USB-Ladeplatine 18650 Akku 1 https://www.banggood.com/5pcs-ESP32S-ESP32-0_5A-Micro-USB-Charger-Board-18650-Battery-Charging-Shield-p-1398716.html? rmmds=myorder&cur_warehouse=DE
• 3,7 V 4000 mAh geschützter wiederaufladbarer 18650 Li-Ion-Akku 1 https://www.banggood.com/4PCS-MECO-3_7v-4000mAh-Protected-Rechargeable-18650-Li-ion-Battery-p-992723.html? rmmds=myorder&cur_warehouse=CN
• Transistor BC547 1
• SUMMER -12MM 1
• Widerstand 1k Ohm 1

Das elektronische Design

Der elektronische Aufbau des Geigerzähler-Bausatzes ist in folgendem Schaltplan dargestellt:

Der Schaltplan des kompletten Geigerzähler-Setups sieht wie folgt aus:

Die 5V-Stromversorgung erfolgt über einen wiederaufladbaren Li-Ion-Akku, der sich in einem Micro-USB-Ladegerät befindet. Die 3, 3 V für das OLED-Display werden von diesem Board genommen.

Das Breadboard-Setup, das zum Testen und Erstellen der Software mit der ARDUINO IDE verwendet wird, ist in der folgenden Abbildung dargestellt:

Mechanische und elektrische Montage

Die Montage aller mechanischen und elektronischen Teile ist in den folgenden Bildern dargestellt:

Beachten Sie, dass der Hand-Geigerzähler keine Kabelverbindungen hat.

Zum Aufladen des 3, 7V Li-Ion Akkus befindet sich im Gehäuse eine separate Öffnung zum (vorübergehenden) Anschluss eines Micro-USB-Steckers.

Für Software-Updates des Arduino Nano steht ein zusätzlicher Mini-USB-Anschluss zur Verfügung.

Schritt 3:Das Software-Design

Das folgende Flussdiagramm zeigt das allgemeine Softwaredesign des Geigerzählers:

Die Ansichten auf dem 0,96-Zoll-OLED-Display sind:

Die vollständige Arduino-Skizze ist unten aufgeführt:

#include 
#include 
#include 
 //Anschlüsse für das OLED-Display
 #define sclk 13 //SCL (blaues Kabel)
#define mosi 11 //SDA (weißes Kabel)
#define cs 10 //CS (graues Kabel)
#define rst 9 / /RES (grünes Kabel)
#define dc 8 //DC (gelbes Kabel)
#define LOGtime 1000 //Logging-Zeit in Millisekunden (1 Sekunde)
#define Minute 60000 //the Zeitraum von 1 Minute zur Berechnung der CPM-Werte
#define show endWrite
#define clear() fillScreen(0)
// Farbdefinitionen
#define BLACK 0x0000
 #define BLAU 0x001F
#define ROT 0xF800
#define GRÜN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define GELB 0xFFE0 
#define WEISS 0xFFFF
Adafruit_SSD1331 display =Adafruit_SSD1331(cs, dc, rst);
int Counts =0; //Variable, die die Anzahl der GM-Tube-Ereignisse innerhalb der LOGtime enthält
unsigned long previousMillis=0; //Variable zum Speichern der vorherigen Zeit
int AVGCPM =0; //Variable, die den gleitenden Durchschnitt der Anzahl der Zählungen über eine feste bewegliche Windo-Periode enthält
int TenSecCPM =0;
int units =0;
int tens =0;
int Hunderter =0;
int Tausende =0;
float Sievert =0;
int COUNTS[10]; // Array zum Speichern der gemessenen Impulsmengen in 10 aufeinanderfolgenden 1-Sekunden-Perioden
int t =0;
////////////////////das Setup der folgende Code wird einmal nach "Power On" oder nach einem RESET ausgeführt ///////////////////
void setup() {
 Serial. begin(115200);
 display.begin();
 display.fillScreen(BLACK);
 
 floatBattery =analogRead(A3); //(orangefarbener Draht)
 floatBattPerc =100 * (Battery/770);
 
 //Serial.print("Batteriewert ="); Serial.println (Batterie); Serial.print ( "Batterieprozentsatz ="); 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++) { //alle Daten im Array COUNTS auf 0 setzen (Array-Positionen laufen von 0 bis 10; 
 COUNTS[x] =0; ///10 Positionen über einen Zeitraum von 10 Sekunden
 }
 
 attachInterrupt(0, IMPULSE, FALLING); //externen Interrupt-Pin D2/INT0 definieren, um die Interrupt-Routine IMPULSE zu starten (grüner Draht )
 
 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);
}
////////////////// //////der folgende Schleifencode wird wiederholt bis "Power Off" oder ein RESET ausgeführt //////////
void loop() 
{
 unsignedlong currentMillis=millis();
 if(currentMillis - previousMillis>LOGtime)
 {
 previousMillis =currentMillis;
 COUNTS[t] =Counts;
 for (int y =0; y <10; y++) { //alle Daten im Array COUNTS zusammen hinzufügen 
 TenSecCPM =TenSecCPM + COUNTS[y]; //und berechne den gleitenden durchschnittlichen CPM über einen Zeitraum von 10 Sekunden
 }
 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); // CPM-Wertfeld auf dem Display löschen
 display.setCursor(4,20);
 display.setTextColor(RED);
 display.setTextSize(2);
 display .println(AVGCPM); 
 //Serial.print ("AVGCPM ="); Serial.print (AVGCPM); //Seriendruck ("CPM ="); Serial.println(CPM);
 display.fillRect(45,38,50,10,BLACK); //lösche das uSv/Hr-Wertfeld auf dem Display
 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 ("Einheiten ="); Serial.println (Einheiten);
 Zehner =int ((10 * Sievert) - (10 * Einheiten)); //Serial.print ("Zehner ="); Serial.println (Zehner);
 Hunderter =int ((100 * Sievert) - (100 * Einheiten) - (10 * Zehner)); //Serial.print ("Hunderte ="); Serial.println (Hunderte); 
 Tausende =int ((1000 * Sievert) - (1000 * Einheiten) - (100 * Zehner) - (10 * Hunderter)); //Serial.print ("Tausende ="); Serial.println (Tausende);
 display.print (Einheiten); display.print("."); display.print (Zehner); display.print (Hunderte);display.println (Tausende);
 
 display.fillRect(1,49,94,14,BLACK); // lösche das CPM-Anzeigefeld auf dem Display
 display.fillRect(1,49,Counts,14,RED); //CPM-Anzeigefeld auf dem Display ausfüllen
 
 Counts =0;
 }
}
////////////// ////SCHLEIFENENDE///////////////////////////////////
//// ////////////////////////////Im Folgenden folgt die Funktion zum Zählen der Anzahl der Impulse vom Geigerzähler-Bausatz
void IMPULSE( )
 {
 Counts++;
 } 

Der wichtigste Teil der Skizze ist die Interrupt-Funktion, die aufgerufen wird, wenn ein Impuls an der GM-Röhre des Geigerzählers gemessen wird, der den INT-Ausgang des Geigerzählers auslöst (indem er für kurze Zeit LOW macht). Das INT-Signal wird mit dem Pin D2 (dem externen Interrupt-Pin INT0 des Arduino Nano) verbunden:

attachInterrupt(0, IMPULSE, FALLING); 

Das INT-Signal startet die Interrupt-Routine IMPULSE () um Counts um 1 zu erhöhen:

void IMPULSE() {Counts++; } 

Nach Ablauf von 1000 Millisekunden:

• die ganze Zahl Counts wird auf 0 zurückgesetzt
• das Array COUNTS [ ] wird mit der Anzahl der in den letzten 1000 Millisekunden gemessenen Zählungen gefüllt
• Die Gesamtzahl der Zählungen in den letzten 10 Sekunden wird berechnet, indem alle Zahlen aus dem Array COUNTS [ ] addiert und mit 6 multipliziert werden, um den CPM-Wert auf dem Display anzuzeigen.
• Die Äquivalentdosis, ausgedrückt in µSv/h, wird durch Division des CPM-Werts durch 151 (ein in der Literatur zu findender Wert) berechnet.
• Auf dem farbigen OLED-Display wird ein roter Balken angezeigt, der auf dem Wert der Counts in der letzten Sekunde basiert, also tatsächlich den CPS-Wert (Counts Per Second) darstellt

Die komplette ARDUINO-Skizze für den Geigerzähler umfasst etwa 150 Codezeilen. Die komplette Auflistung ist Teil dieses Tutorials, der ARDUINO-Code (siehe Kapitel 9) ist mit einer Fülle von Kommentaren versehen.

Code

• Geiger_Counter.ino

Geiger_Counter.inoArduino

/********* Dieses Projekt wurde entwickelt und produziert von Pierre Pennings (Dezember 2019). ein fertiges Geigerzähler-Kit, in einem 3D-gedruckten tragbaren Strahlungsdetektor, De Kit ist mit einem Arduino Nano verbunden, der die Anzahl der Impulse von der Geiger/Müller-Röhre in einem Zeitraum von 10 Sekunden zählt und dann den durchschnittlichen CPM (Counts Per Minute) auf einem 96*64 OLED-Farbdisplay. Der gemessene CPM wird auch als Mikrosievert pro Stunde (mit einem einfachen Umrechnungsfaktor von 151) angezeigt. Das OLED-Display zeigt auch die momentan gemessene Impulsanzahl (pro Sekunde) an und zeigt die Messwerte als sich bewegender roter Balken auf dem Display an. Das 3D-gedruckte Gehäuse enthält auch den 18650-Ion Lithium-Akku (wiederaufladbar), der den Arduino Nano mit 5V versorgt, sowie das Geigerzähler-Kit und 3,3V für das OLED-Display. Ein Einschaltschalter und ein externer Beeper vervollständigen den Detektor. Beim Einschalten wird der Ladezustand des 18650-Akkus auf dem Farbdisplay angezeigt. Dieser Code ist unter der GPL3+-Lizenz lizenziert. *********/#include #include #include  //Anschlüsse für das OLED-Display#define sclk 13 //SCL (blaues Kabel)# define mosi 11 //SDA (weißes Kabel)#define cs 10 //CS (graues Kabel)#define rst 9 //RES (grünes Kabel)#define dc 8 //DC (gelbes Kabel)#define LOGtime 1000 //Logging Zeit in Millisekunden (1 Sekunde)#define Minute 60000 //der Zeitraum von 1 Minute zur Berechnung der CPM-Werte#define show endWrite#define clear() fillScreen(0)// Farbdefinitionen#define BLACK 0x0000#define BLUE 0x001F#define ROT 0xF800#define GRÜN 0x07E0#define CYAN 0x07FF#define MAGENTA 0xF81F#define YELLOW 0xFFE0 #define WEISS 0xFFFFadafruit_SSD1331 display =Adafruit_SSD1331(cs, dc, rst);int Counts =0; // Variable, die die Anzahl der GM-Röhren-Ereignisse innerhalb der LOGtime enthältunsigned long previousMillis =0; //Variable zum Speichern des vorherigen Timeint AVGCPM =0; //Variable, die den gleitenden Durchschnitt der Anzahl der Zählungen über ein festes bewegliches Fenster enthält periodint TenSecCPM =0;int units =0;int tens =0;int Hunderter =0;int Tausende =0;float Sievert =0;int COUNTS[10]; // Array zum Speichern der gemessenen Impulsmengen in 10 aufeinanderfolgenden 1-Sekunden-Periodenint t =0;////////////////////der folgende Setup-Code wird einmal ausgeführt "Power On" oder nach einem RESET ///////////////////void setup () { Serial.begin (115200); display.begin(); display.fillScreen (SCHWARZ); Schwimmerbatterie =analogRead (A3); // (orangefarbener Draht) Schwimmer BattPerc =100 * (Batterie/770); //Serial.print ("Batteriewert ="); Serial.println (Batterie); Serial.print ("Batterieprozentsatz ="); 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(" %"); Verzögerung (3000); display.fillScreen (SCHWARZ); for (int x =0; x <10; x++) {//alle Daten im Array COUNTS auf 0 setzen (Array-Positionen laufen von 0 bis 10; COUNTS[x] =0; //10 Positionen über einen Zeitraum von 10 Sekunden} attachInterrupt (0, IMPULSE, FALLING); // Definiere externen Interrupt an Pin D2/INT0, um die Interrupt-Routine IMPULSE (grüner Draht) zu starten 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);}////////////////////////der Loop-Code, der folgt, wird wiederholt bis "Power Off" oder ein RESET ausgeführt /////////void loop() { unsigned long currentMillis =millis(); if(currentMillis - previousMillis> LOGtime) { previousMillis =currentMillis; COUNTS[ t] =zählt, für (int y =0; y <10; y++) { //alle Daten im Array COUNTS zusammen hinzufügen TenSecCPM =TenSecCPM + COUNTS[y]; //und berechne den gleitenden durchschnittlichen CPM über einen Zeitraum von 10 Sekunden} 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,SCHWARZ); // Löschen Sie das CPM-Wertfeld auf dem Display display.setCursor (4,20); display.setTextColor(RED); display.setTextSize(2); display.println (AVGCPM); //Serial.print ("AVGCPM ="); Seriendruck (AVGCPM); //Seriendruck ("CPM ="); Serial.println (CPM); display.fillRect(45,38,50,10,SCHWARZ); // lösche das uSv/Hr-Wertfeld auf dem Display display.setCursor(45,38); display.setTextColor (GRÜN); display.setTextSize(1); Sievert =(AVGCPM /151,0); //Serial.print ("Sievert ="); Serial.println (Sievert); Einheiten =int (Sievert); //Serial.print ("Einheiten ="); Serial.println (Einheiten); Zehner =int ((10*Sievert) - (10*Einheiten)); //Serial.print ("Zehner ="); Serial.println (Zehner); Hunderter =int ((100 * Sievert) - (100 * Einheiten) - (10 * Zehner)); //Serial.print ("Hunderte ="); Serial.println (Hunderte); Tausend =int ((1000 * Sievert) - (1000 * Einheiten) - (100 * Zehner) - (10 * Hunderter)); //Serial.print ("Tausende ="); Serial.println (Tausende); display.print (Einheiten); display.print("."); display.print (Zehner); display.print (Hunderte); display.println (Tausende); display.fillRect(1,49,94,14,SCHWARZ); // Löschen Sie das CPM-Anzeigefeld auf dem Display display.fillRect(1,49,Counts,14,RED); // Füllen Sie das CPM-Indikatorfeld auf dem Display aus Counts =0; }}//////////////////SCHLEIFENENDE ////////////////////////// /////////////////////////////////////////Im Folgenden folgt die Funktion zum Zählen der Zahl von Impulsen vom Geigerzähler kitvoid IMPULSE() { Counts++; }

Kundenspezifische Teile und Gehäuse

Schaltpläne