Costruire un rilevatore tascabile di radiazioni con modulo Geiger

Utilizziamo un modulo con tubo Geiger per costruire un rilevatore tascabile di radiazioni. Il tutto gestito da un piccolo ATtiny85 e alimentato con una batteria al litio ricaricabile

Si sente (troppo) spesso parlare di nucleare e sappiamo tutti quali conseguenze può portare un’esposizione prolungata alle invisibili radiazioni. Non sono molti i modi per scoprire se la zona in cui viviamo è “infetta”, ma tra questi il contatore Geiger Muller è sicuramente tra i più conosciuti.

Partendo da queste considerazioni abbiamo scelto di realizzare un contatore Geiger «tascabile» dalle ridottissime dimensioni, (soli 9cm x 5cm) in grado di funzionare con una semplice batteria LiPo per un’intera giornata e dotato di carica batteria integrato, utilizzabile anche per la sua alimentazione.

Il progetto sfrutta un potente, ma estremamente compatto, modulo, che effettua fisicamente la rilevazione delle “radiazioni” e la loro “conta”.

Il sensore, chiamato RadSense, è dotato di un piccolo LED che lampeggia proporzionalmente agli impulsi ricevuti, quindi è semplice capire che stia lavorando correttamente.

Il RadSense è connesso ad un piccolo ATtiny85 che svolge il compito di gestire l’acquisizione dei dati (via bus I2C) e la loro visualizzazione su un display OLED da 0.96”.

Assieme a questi due componenti di base viene utilizzato un modulo per la ricarica delle batterie LiPo, una circuiteria per permettere l’utilizzo del “contatore” anche durante la ricarica della batteria ed un regolatore di tensione per avere i 3,3V, necessari a far funzionare tutta l’elettronica.

Il cuore del progetto è certamente il modulo RadSense, visibile in Fig. 1 e le cui caratteristiche sono riportate nella Tabella 1.

 

 

Tale modulo monta di base un tubo Geiger SBM 20-1, ma è in grado di montare anche tubi differenti quali J305, M4011, STS-5 ed altri.

A bordo ha tutta l’elettronica necessaria per generare l’alta tensione (400 V) partendo dalla tensione di alimentazione di 3,3V e una MCU STM32 che svolge i compiti più gravosi di acquisizione dei dati, gestione dell’elettronica (è in grado di spegnere ed accendere il convertitore ad alta tensione, ai fini di risparmio energetico, attraverso comandi software) e colloquio con una MCU esterna via bus I2C.

Ha dimensioni estremamente ridotte, solo 89 x 21 x 16 mm ed è facilmente fissabile sul circuito stampato su cui è basato il nostro progetto.

A completamento dell’hardware, su GitHub, è possibile scaricare la libreria, direttamente installabile nell’IDE di Arduino, per la sua gestione attraverso semplici chiamate a funzioni (https://github.com/climateguard/RadSens).

Il firmware presente a bordo di detto modulo, e che gira all’interno del STM32, permette di avere già pronte le seguenti misurazioni recuperabili via I2C:

• Intensità delle radiazioni (μR/h) con l’utilizzo di un algoritmo per il calcolo della media su lunghi periodi (500 secondi).
• Intensità delle radiazioni (μR/h) con l’utilizzo di un algoritmo dinamico per una rilevazione più immediata di radiazioni locali.
• Numero degli impulsi ricevuti; valore da utilizzare tra due letture per poter approssimare il valore cps (count per second) o cpm (count per minute).

Dato che molti lettori non sono attrezzati per lavorare con componentistica SMD e dato che comunque, causa le dimensioni del modulo Geiger, vi era lo spazio necessario per posizionare i componenti tradizionali, si è scelto di utilizzare tutti componenti “through-hole” facilmente montabili e saldabili da qualsiasi appassionato.

Lo schema elettrico del contatore Geiger

Analizziamo lo schema elettrico che, come potete vedere nella pagina seguente, è molto semplice.

Partiamo dalla sezione di alimentazione e in particolare dal modulo carica batterie LiPo (codice 1ALITIOBATT).

Il circuito è in grado di fornire fino a 1A ed è dotato di un connettore USB che sfrutteremo sia per ricaricare la batteria che, volendo, per alimentare il nostro circuito.

Per ottenere quest’ultima possibilità, è presente un MOSFET (Q1) che, quando si fornisce alimentazione tramite la porta USB, isola la batteria dal resto del nostro circuito e utilizza i 5V come tensione d’ingresso per il regolatore U2, un MCP1702-330, che provvede a generare i 3,3V necessari. Quando la USB non è connessa, Q1 invia la tensione della batteria al detto regolatore.

I pin PB0 e PB2 del ATtiny85 (U1) sono utilizzati come bus I2C (tramite la classica libreria Wire.h), mentre il pin PB1 è utilizzato semplicemente come “test point”.

Se tutto funziona regolarmente tale pin cambia stato con periodo di un secondo, se invece, in fase di avvio del programma, viene rilevata un’anomalia, tale periodo cambia (se non si riesce ad inizializzare la libreria del sensore RadSense il programma si blocca e su detto pin viene generato un segnale che cambia di stato ogni 100 msec.).

Per il modulo OLED abbiamo previsto due file di pin, difatti, purtroppo, tali schermi OLED esistono con due piedinature diverse (con i pin GND e VCC invertiti) ed in questo modo è possibile montare sul circuito entrambi i tipi.

Come vedete dal piano di montaggio, la fila superiore di piazzole per il display OLED da 0.96” prevede la piedinatuta: GND, VCC, SCL, SDA, mentre la fila inferiore prevede: VCC, GND, SCL, SDA.

Per terminare segnaliamo che le resistenze R3 ed R4, con funzione di pull-up sui segnali SCL ed SDA del bus I2C, sono state previste ma non montate dato che i moduli OLED da 0.96” già le incorporano.

Come batteria LiPo si suggerisce di utilizzare una batteria con capacità di 800/1000mA che, dato l’esiguo assorbimento del circuito (circa 70/80 mA), ne garantirà il funzionamento per un’intera giornata lavorativa.

Prestare solo attenzione alla polarità del connettore: come visibile dal piano di montaggio il positivo è a sinistra ed il negativo è a destra sul connettore JST-PH.

Come il resto dei componenti anche il cuore del progetto, il microcontrollore ATtiny85 è in formato DIP8 ed è stato quindi montato su zoccolo così da permettere la facile estrazione e reinserimento sia per la sua programmazione iniziale che per l’applicazione di eventuali futuri aggiornamenti del codice.

| piano di montaggio del contatore geiger

Elenco Componenti:

R1, R2: 10 kohm
R3, R4: 4,7 kohm
C1: 0,1 µF multistrato
C2, C3: 1 µF multistrato
D1: 1N5818
Q1: VP3203
U1: ATTINY85-20P
U2: MCP1700
M1: LiPo charger
SW1: deviatore da c.s.
TP1: pin strip 2 poli maschio
J1: pin strip 4 poli maschio
J2: pin strip 2x4 poli maschio
J3: JST 2 poli P-2 mm

Varie:
-modulo RadSense v1.2
-distanziale HEX 6 mm M/F M2 Nylon
-vite M2x4 Nylon
-dado M2 Nylon
-Circuito stampato S1603 (93x52 mm)

Il codice

Passiamo ora alla parte “software” del nostro circuito, ovvero quello che gira all’interno del ATtiny85 e che ne controlla tutte le funzionalità.

Come “core” per la programmazione del ATtiny85, attraverso l’IDE di Arduino, si è utilizzato quello di Spence Konde “ATtinyCore” che si installa attraverso il “Board Manager” del IDE dopo aver aggiunto, dal menu “Preferenze”, il relativo file JSON.

Oltre a questo occorre installare, nella cartella delle librerie, la libreria per la gestione del RadSense ed una libreria, particolarmente “leggera” (sotto il profilo utilizzo di risorse), per la gestione del OLED, la “SSD1306Ascii”, installabile attraverso il “Library Manager” del IDE.

Il programma inizia includendo tutte le librerie necessarie e prosegue con la definizione di una serie di costanti (#define) che, con nomi mnemonici, ci permettono una più chiara e leggibile scrittura del codice come visibile nel Listato1.

Listato 1

#include <Wire.h>
#include <radSens1v2.h>
#include <SSD1306Ascii.h>
#include <SSD1306AsciiWire.h>
#define VCC_MIN 2900 // minimum voltage on Vcc in milliVolt
#define TP_PIN 1 // Test Point Pin
#define TP_PIN_TIME 1000 // Normal TP interval
#define OLED_I2C 0x3C // OLED I2C address
#define OLED_TIME 1000 // OLED diplay period
#define ROW_DYN 2 // OLED row for radIntensyDyanmic
#define ROW_STA 4 // OLED row for radIntensyStatic
#define ROW_CPM 6 // OLED row for CPM

Vengono poi istanziate le classi necessarie e definite le variabili globali (Listato 2).

Listato 2

SSD1306AsciiWire oled;

ClimateGuard_RadSens1v2 radSens ( RS_DEFAULT_I2C_ADDRESS );

uint8_t fFirstReading = true; // first 15 sec waiting for CMP
uint8_t rad_Status = 0; // radSense return status
uint32_t radNumberOfPulses = 0; // the number of registered impulses
uint32_t lstNumberOfPulses = 0; // last number of registered impulses read from radSense
uint32_t numberOfPulsesMin = 0; // the number of impulses per minute (CPM)
uint32_t radLastMillis = 0; // last time RadSense was read
uint32_t pulseLastMillis = 0; // last time CMP was calculated
uint32_t oledMillis = 0; // last time OLED was updated
float radIntensyDyanmic = 0.0; // radiation in uR/h with a dynamic range of calculation time
float radIntensyStatic = 0.0; // radiation in uR/h with averaging algorithm (for long time period)
uint8_t tp_Status = LOW; // TP (Test Point) initial status
uint32_t tpLastMillis = 0; // TP last change status time

Terminata questa fase “dichiarativa”, il programma prosegue con una serie di funzioni che vengono richiamate durante l’esecuzione.

L’unica degna di nota e di essere mostrata, è quella che implementa il cosidetto “Secret Voltmeter” (Listato 3): possibilità che è presente nelle MCU della vecchia famiglia Atmel AVR, ovvero la capacità di leggere e conoscere da programma la tensione di alimentazione presente sul pin VCC.

Tale funzione, se chiamata, restituisce il valore della tensione di alimentazione in mVolt.

Listato 3

uint32_t readVcc() {
uint8_t low;
uint8_t high;
uint32_t result;
// Read 1.1V reference against AVcc
// set the reference to Vcc and the measurement to the internal 1.1V reference
#if defined(__AVR_ATmega32U4__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
ADMUX = _BV ( REFS0 ) | _BV ( MUX4 ) | _BV ( MUX3 ) | _BV ( MUX2 ) | _BV ( MUX1 );
#elif defined (__AVR_ATtiny24__) || defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__)
ADMUX = _BV ( MUX5 ) | _BV ( MUX0 );
#elif defined (__AVR_ATtiny25__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)
ADMUX = _BV ( MUX3 ) | _BV ( MUX2 );
#else
ADMUX = _BV ( REFS0 ) | _BV ( MUX3 ) | _BV ( MUX2 ) | _BV ( MUX1 );
#endif
delay ( 2 ); // Wait for Vref to settle
ADCSRA |= _BV ( ADSC ); // Start conversion
while ( bit_is_set ( ADCSRA, ADSC ) ); // measuring
low = ADCL; // must read ADCL first - it then locks ADCH
high = ADCH; // unlocks both
result = ( high << 8 ) | low;
result = 1125300L / result; // Calculate Vcc (in mV); 1125300 = 1.1*1023*1000
return result; // Vcc in millivolts

Nel programma tale valore viene confrontato con un valore fisso, determinato dalla definizione:

#define VCC_MIN 2900 // minimum VCC voltage in mV

Se il dato letto scende sotto tale valore (modificabile da programmatore secondo le esigenze), il programma si blocca e chiede all’operatore di ricaricare la batteria. Il resto del codice è molto semplice e non viene qui riportato, ma è ovviamente scaricabile per intero dalla sezione download qui sotto.

In pratica esso, con una determinata periodicità (fissata a 30 secondi), legge le informazioni dal modulo RadSense e le visualizza sul display OLED.

I valori di radioattività vengono visualizzati sul display OLED in µSv/h (micro Sievert/ora) con la semplice formula di conversione per cui un Sv è pari a 100 Rem per cui, preso il valore fornito dal modulo RadSense (che, ricordiamo, è in µRem) lo si divide per 100 per ottenere il valore in µSv.

Costruzione del rilevatore di radiazioni

Come già accennato più volte il circuito è stato realizzato con componenti discreti e quindi facilmente saldabile.

Prestate attenzione al circuito del sensore che deve essere fissato tramite viti al PCB madre e deve essere collegato a questo tramite un connettore 4 vie.

Il modulo caricabatteria viene saldato direttamente sul PCB tramite le sue quattro piazzole.

Il circuito montato può essere inserito all’interno di un piccolo contenitore plastico che può essere stampato in 3D o realizzato tramite taglio laser.

Durante l’uso evitate di toccare il tubo Geiger, non tanto per l’alta tensione (circa 400V, ma la corrente fornibile è talmente bassa che praticamente non la si sente), quanto perché toccando il tubo si falsano tutte le misure.

Programmare l’ATtiny

Per caricare il firmware all’interno del microcontrollore potete utilizzare l’IDE Arduino.

Per farlo dovrete selezionare la corretta “board” e le corrette impostazioni, per semplificare l’operazione trovate nella Fig. 2 i parametri esatti.

 

 

Il microcontrollore ATtiny85 deve essere programmato tramite un programmatore collegato tramite ISP, programmatore che, volendo, può anche essere realizzato utilizzando una scheda Arduino (AVR) e l’apposito programma “Arduino as ISP” ricordando i collegamenti con l’ATtiny (Fig. 3)

Per impostare correttamente i FUSE del ATtiny85 (clock interno a 8MHz, BOD disabilitato, …), connessa la MCU al programmatore, occorre selezionare, dagli strumenti dell’IDE, l’opzione per “caricare il bootloader”.

Dato che, come visibile, abbiamo scelto la “board” senza bootloader, in realtà nella MCU non verrà caricato alcunché, ma verranno invece correttamente programmati i FUSE.

Download codice per contatore Geiger

Download del Gerber per contatore Geiger

Conclusioni

Eccoci giunti alla conclusione di questo progetto.

Il sensore RadSense si è rivelato estremamente semplice da utilizzare, grazie principalmente alla sua elettronica che risolve molti problemi.

Resta a voi prendere spunto da questo progetto per poter realizzare anche qualcosa di più complesso, ad esempio un sistema in grado di inviare notifiche in caso in cui la radiazione superi certi livelli.

Sperando di non averne mai bisogno…