Contador Geiger de mano con Arduino Nano

Acerca de este proyecto

Este proyecto comenzó después de que compré un kit de contador Geiger confeccionado de Banggood.

La idea era colocar este kit en una carcasa impresa en 3D para que el conjunto completo de contadores Geiger en funcionamiento pudiera ser portátil. El resultado final se muestra a continuación:

Paso 1:Diseño del sistema

El diseño del contador Geiger portátil se muestra en el siguiente diagrama:

El contador Geiger está equipado con una pantalla OLED a color de 0,96 pulgadas, que informa al usuario sobre el CPM medido (medida de la tasa de detección de eventos de ionización por minuto), así como la dosis equivalente (calculada) en µSv / hr usando un factor simple de 151 que se pueden encontrar en la literatura para el tipo de tubo Geiger-Müller (GM) utilizado.

Véase también Wikipedia:https://en.wikipedia.org/wiki/Counts_per_minute

De hecho, el CPM mostrado es el resultado de un cálculo de recuentos durante un minuto, midiendo los recuentos por segundo (CPS) y almacenando estas medidas en una matriz que cubre el período de los últimos diez segundos. El número total de recuentos durante los últimos 10 segundos se multiplica por 6 para obtener el valor de CPM.

El número de conteos durante el último segundo se usa para mostrar el número momentáneo de mediciones a través de un gráfico de barras en la pantalla OLED. Esto es útil en caso de tasas de conteo altas o cuando ocurren cambios rápidos en la tasa de conteo cuando el contador portátil se mueve sobre una fuente de radiación.

El contador Geiger funciona con una batería de iones de litio tipo 18650, que se puede cargar a través de un conector micro-USB. También se puede acceder al puerto Arduino Nano USB para cambios de software. Se conecta un zumbador adicional a la placa del contador Geiger para mejorar el sonido de las ionizaciones en el tubo GM.

Todos los componentes electrónicos del contador Geiger están integrados en la carcasa impresa en 3D:

La pantalla OLED se coloca en una caja separada en la parte superior del contador Geiger:

La versión completamente ensamblada:

Paso 2:Hacer el ensamblaje del contador Geiger

Se utilizan los siguientes materiales:

• Arduino NANO 1 https://store.arduino.cc/arduino-nano
• Kit de contador Geiger 1 https://uk.banggood.com/Assembled-DIY-Geiger-Counter-Kit-Module-Miller-Tube-GM-Tube-Nuclear-Radiation-Detector-p-1136883.html?rmmds =búsqueda &cur_warehouse =CN
• Pantalla a color OLED de 0.96 "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
• Placa de cargador micro USB 18650 Batería 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 =Reino Unido
• 3.7v 4000mAh Batería recargable de iones de litio 18650 protegida 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
• ZUMBADOR -12MM 1
• Resistencia 1k Ohm 1

El diseño electrónico

El diseño electrónico del kit de contador Geiger se muestra en el siguiente diagrama de circuito:

El diagrama de circuito de la configuración completa del contador Geiger es el siguiente:

La alimentación de 5 V se suministra desde una batería de iones de litio recargable colocada en una placa de carga micro USB. Los 3, 3 V para la pantalla OLED se toman de esta placa.

La configuración de la placa de pruebas utilizada para probar y compilar el software con ARDUINO IDE se muestra en la siguiente imagen:

Ensamblaje mecánico y eléctrico

El montaje de todas las piezas mecánicas y electrónicas se muestra en las siguientes imágenes:

Tenga en cuenta que el contador Geiger de mano no tiene conexiones de cable.

Para cargar la batería de iones de litio de 3, 7 V, hay una abertura separada en la carcasa para conectar (temporalmente) un enchufe micro USB.

Hay disponible una conexión mini USB adicional para las actualizaciones de software del Arduino Nano.

Paso 3:el diseño del software

El siguiente diagrama de flujo muestra el diseño general del software del Contador Geiger:

Las vistas en la pantalla OLED de 0, 96 ”son:

El boceto completo de Arduino se enumera a continuación:

  #include  
 #include  
 #include  
 // Conexiones para la pantalla OLED 
 #define sclk 13 // SCL (cable azul) 
 #define mosi 11 // SDA (cable blanco) 
 #define cs 10 // CS (cable gris) 
 #define rst 9 / / RES (cable verde) 
 #define dc 8 // DC (cable amarillo) 
 #define LOGtime 1000 // Tiempo de registro en milisegundos (1 segundo) 
 #define Minute 60000 // the período de 1 minuto para calcular los valores de CPM 
 #define show endWrite 
 #define clear () fillScreen (0) 
 // Definiciones de color 
 #define BLACK 0x0000 
 #define AZUL 0x001F 
 #define ROJO 0xF800 
 #define GREEN 0x07E0 
 #define CYAN 0x07FF 
 #define MAGENTA 0xF81F 
 #define AMARILLO 0xFFE0 
 #define BLANCO 0xFFFF 
 Adafruit_SSD1331 display =Adafruit_SSD1331 (cs, dc, rst); 
 int Counts =0; // variable que contiene el número de eventos de GM Tube dentro del LOGtime 
 unsigned long previousMillis =0; // variable para almacenar el tiempo anterior 
 int AVGCPM =0; // variable que contiene el número medio flotante de recuentos durante un período de ventana móvil fijo 
 int TenSecCPM =0; 
 int unidades =0; 
 int decenas =0; 
 int centenas =0; 
 int miles =0; 
 float Sievert =0; 
 int COUNTS [10]; // matriz para almacenar las cantidades medidas de impulsos en 10 períodos consecutivos de 1 segundo 
 int t =0; 
 ////////////////////// la configuración código que sigue, se ejecutará una vez después de "Encendido" o después de un RESET ///////////////////// 
 void setup () {
 Serial. begin (115200); 
 display.begin (); 
 display.fillScreen (BLACK); 
 
 floatBattery =analogRead (A3); // (cable naranja) 
 floatBattPerc =100 * (Battery / 770); 
 
 //Serial.print("battery value ="); Serial.println (batería); Serial.print ("porcentaje de batería ="); Serial.println (BattPerc); 
 display.setCursor (4,4); 
 display.setTextSize (2); 
 display.setTextColor (MAGENTA); 
 display.println ( "Batería"); 
 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 ++) {// poner todos los datos en el Array COUNTS en 0 (Array positionrun from 0 to 10; 
 COUNTS [x] =0; // 10 posiciones que cubren un período de 10 segundos 
} 
 
 attachInterrupt (0, IMPULSE, FALLING); // define el pin de interrupción externa D2 / INT0 para iniciar la rutina de interrupción IMPULSE (cable verde ) 
 
 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 seg"); 
 display.setCursor (50,12); 
 display.print ("ventana"); 
 
 display.setCursor (4, 38); 
 display.setTextSize (1); 
 display.setTextColor (VERDE); 
 display.print ("uSv / hr"); 
 
 display. drawRect (0,48, 96, 16, AMARILLO); 
} 
 ////////////////// ////// el código de ciclo que sigue, se ejecutará repetidamente hasta "Apagar" o un RESET ///////// 
 bucle vacío () 
 {
 unsignedlong currentMillis =millis (); 
 if (currentMillis - previousMillis> LOGtime) 
 {
 previousMillis =currentMillis; 
 COUNTS [t] =Counts; 
 for (int y =0; y <10; y ++) {// suma todos los datos en el Array COUNTS juntos 
 TenSecCPM =TenSecCPM + COUNTS [y]; // y calcular el CPM promedio móvil durante un período de 10 segundos 
} 
 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, NEGRO); // borra el campo de valor de CPM en la pantalla 
 display.setCursor (4,20); 
 display.setTextColor (RED); 
 display.setTextSize (2); 
 display .println (AVGCPM); 
 //Serial.print ("AVGCPM ="); Impresión serial (AVGCPM); //Serial.print ("CPM ="); Serial.println (CPM); 
 display.fillRect (45,38,50,10, NEGRO); // borra el campo de valor uSv / Hr en la pantalla 
 display.setCursor (45,38); 
 display.setTextColor (GREEN); 
 display.setTextSize (1); 
 
 Sievert =(AVGCPM /151.0); //Serial.print ("Sievert ="); Serial.println (Sievert); 
 unidades =int (Sievert); //Serial.print ("unidades ="); Serial.println (unidades); 
 tens =int ((10 * Sievert) - (10 * unidades)); //Serial.print ("tens ="); Serial.println (decenas); 
 centenas =int ((100 * Sievert) - (100 * unidades) - (10 * decenas)); //Serial.print ("cientos ="); Serial.println (cientos); 
 miles =int ((1000 * Sievert) - (1000 * unidades) - (100 * decenas) - (10 * cientos)); //Serial.print ("miles ="); Serial.println (miles); 
 display.print (unidades); display.print ("."); display.print (decenas); display.print (cientos); display.println (miles); 
 
 display.fillRect (1,49,94,14, NEGRO); // limpia el campo del indicador CPM en la pantalla 
 display.fillRect (1,49, Counts, 14, RED); // llene el campo del indicador de CPM en la pantalla 
 
 Recuentos =0; 
} 
} 
 ////////////// //// FIN DE BUCLE ////////////////////////////////////// 
 //// ///////////////////////////// A continuación, sigue la Función para contar el número de impulsos del kit Geiger Counter 
 void IMPULSE ( ) 
 {
 Recuentos ++; 
}  

La parte más importante del esquema es la función de interrupción que se llama cuando se mide un impulso en el tubo GM del Contador Geiger que activa la salida INT del Geigercounter (haciéndola BAJA durante un período corto). La señal INT está conectada al pin D2 (el pin de interrupción externo INT0 del Arduino Nano):

  attachInterrupt (0, IMPULSE, FALLING);  

La señal INT iniciará la rutina de interrupción IMPULSE () para aumentar los conteos con 1:

  void IMPULSE () {Recuentos ++; }  

Después del lapso de 1000 milisegundos:

• el recuento de números enteros se vuelve a poner en 0
• la matriz COUNTS [] se llena con la cantidad de conteos medidos durante los últimos 1000 milisegundos
• el número total de recuentos durante los últimos 10 segundos se calcula sumando todos los números de la matriz COUNTS [] y se multiplica por 6 para presentar el valor de CPM en la pantalla.
• La dosis equivalente expresada en µSv / hr se calcula dividiendo el valor de CPM con151 (un valor que se encuentra en la literatura).
• En la pantalla OLED a color, se muestra una barra roja basada en el valor de los recuentos en el último segundo, por lo que, de hecho, presenta el valor de CPS (recuentos por segundo)

El boceto ARDUINO completo para el contador Geiger comprende aproximadamente 150 líneas de código. La lista completa se incluye como parte de este tutorial, el código ARDUINO (ver capítulo 9) se proporciona con una amplia cantidad de comentarios.

 / ********* Este proyecto ha sido desarrollado y producido por Pierre Pennings (diciembre de 2019). Este proyecto trata sobre la fabricación de un contador Geiger portátil utilizando Un kit de contador Geiger listo para usar, en un detector de radiación portátil impreso en 3D, el kit De está conectado a un Arduino Nano que cuenta el número de impulsos del tubo Geiger / Muller en un período de 10 segundos y luego muestra el CPM promedio (recuentos por Minuto) en una pantalla a color OLED de 96 * 64. El CPM medido también se muestra como micro Sievert por hora (con un factor de conversión simple de 151). La pantalla OLED también muestra la cantidad medida momentánea de impulsos (por segundo) y muestra las mediciones como una barra roja en movimiento en la pantalla. La carcasa impresa en 3D también contiene la batería de litio 18650-Ion (recargable) que proporciona la potencia de 5V al Arduino Nano, así como al kit Geiger Counter y 3,3V para la pantalla OLED. Un interruptor de encendido y un zumbador externo completan el detector. Al encender, el nivel de carga de la batería 18650 se muestra en la pantalla a color. Este código tiene licencia GPL3 +. ********* / # include  #include  #include  // Conexiones para la pantalla OLED # define sclk 13 // SCL (cable azul) # definir mosi 11 // SDA (cable blanco) #define cs 10 // CS (cable gris) #define rst 9 // RES (cable verde) #define dc 8 // DC (cable amarillo) #define LOGtime 1000 // Logging tiempo en milisegundos (1 segundo) #define Minute 60000 // el período de 1 minuto para calcular los valores de CPM # define show endWrite # define clear () fillScreen (0) // Definiciones de color # define BLACK 0x0000 # define BLUE 0x001F # define ROJO 0xF800 # define VERDE 0x07E0 # define CYAN 0x07FF # define MAGENTA 0xF81F # define AMARILLO 0xFFE0 #define BLANCO 0xFFFFAdafruit_SSD1331 display =Adafruit_SSD1331 (cs, dc, rst); int Counts =0; // variable que contiene el número de eventos de GM Tube dentro de LOGtimeunsigned long previousMillis =0; // variable para almacenar el timeint anterior AVGCPM =0; // variable que contiene el número medio flotante de recuentos sobre una ventana móvil fija periodint TenSecCPM =0; int unidades =0; int decenas =0; int cientos =0; int miles =0; float Sievert =0; int COUNTS [10]; // matriz para almacenar las cantidades medidas de impulsos en 10 periodos consecutivos de 1 segundoint t =0; //////////////////// el código de configuración que sigue, se ejecutará una vez después "Encendido" o después de un RESET ///////////////////// void setup () {Serial.begin (115200); display.begin (); display.fillScreen (NEGRO); Batería flotante =analogRead (A3); // (cable naranja) float BattPerc =100 * (Battery / 770); //Serial.print ("valor de la batería ="); Serial.println (batería); Serial.print ("porcentaje de batería ="); Serial.println (BattPerc); display.setCursor (4,4); display.setTextSize (2); display.setTextColor (MAGENTA); display.println ("Batería"); display.setCursor (4,24); display.print (int (BattPerc)); display.print ("."); display.print (int ((10 * BattPerc) - (10 * int (BattPerc)))); display.print ("%"); retraso (3000); display.fillScreen (NEGRO); for (int x =0; x <10; x ++) {// poner todos los datos en la matriz COUNTS en 0 (las posiciones de la matriz van de 0 a 10; COUNTS [x] =0; // 10 posiciones que cubren un período de 10 segundos} attachInterrupt (0, IMPULSE, FALLING); // define la interrupción externa en el pin D2 / INT0 para iniciar la rutina de interrupción IMPULSE (cable verde) 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 (" ventana "); display.setCursor (4,38); display.setTextSize (1); display.setTextColor (VERDE); display.print (" uSv / hr "); display.drawRect (0,48, 96, 16, AMARILLO);} ////////////////////////// el código de bucle que sigue, se ejecutará repetidamente hasta "Apagar" o un RESET ///////// vacío loop () {unsigned long currentMillis =millis (); if (currentMillis - previousMillis> LOGtime) {previousMillis =currentMillis; COUNTS [ t] =Cuenta; para (int y =0; y <10; y ++) {// agregar todos los datos en el Array COUNTS juntos TenSecCPM =TenSecCPM + COUNTS [y]; // y calcular el CPM promedio móvil durante un período de 10 segundos} 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, NEGRO); // borra el campo de valor de CPM en la pantalla display.setCursor (4,20); display.setTextColor (RED); display.setTextSize (2); display.println (AVGCPM); //Serial.print ("AVGCPM ="); Impresión serial (AVGCPM); //Serial.print ("CPM ="); Serial.println (CPM); display.fillRect (45,38,50,10, NEGRO); // limpia el campo de valor uSv / Hr en la pantalla display.setCursor (45,38); display.setTextColor (VERDE); display.setTextSize (1); Sievert =(AVGCPM /151.0); //Serial.print ("Sievert ="); Serial.println (Sievert); unidades =int (Sievert); //Serial.print ("unidades ="); Serial.println (unidades); decenas =int ((10 * Sievert) - (10 * unidades)); //Serial.print ("tens ="); Serial.println (decenas); centenas =int ((100 * Sievert) - (100 * unidades) - (10 * decenas)); //Serial.print ("cientos ="); Serial.println (cientos); miles =int ((1000 * Sievert) - (1000 * unidades) - (100 * decenas) - (10 * centenas)); //Serial.print ("miles ="); Serial.println (miles); display.print (unidades); display.print ("."); display.print (decenas); display.print (cientos); display.println (miles); display.fillRect (1,49,94,14, NEGRO); // limpiar el campo del indicador CPM en la pantalla display.fillRect (1,49, Counts, 14, RED); // llene el campo del indicador CPM en la pantalla Counts =0; }} //////////////////// FIN DEL BUCLE ///////////////////////////// //////////////////////////////////////////// A continuación, sigue la función para contar el número de impulsos de Geiger Counter kitvoid IMPULSE () {Counts ++; }