Ripescando tra le vecchie schede che mi ritrovavo in uno scatolone ho ritrovato questo contatore Geiger perfettamente funzionante da interfacciare come shield ad Arduino. In questo articolo vedremo insieme le sue funzionalità, e allo stesso tempo comprendendo meglio cosa sia e come funzioni un contatore Geiger, o sensore di radiazioni.
La Scheda Shield della Libelium
La scheda shield da interfacciare ad Arduino è distribuita dalla Libelium. La struttura della scheda è divisa in due diverse parti:
- circuito di segnale
- circuito di potenza
La parte dedicata al circuito di potenza è in grado di fornire un alto voltaggio (400V-1000V) necessario assolutamente per il funzionamento del tubo Geiger. Per ottenere un così alto voltaggio si utilizzano diversi diodi Zener connessi in serie.
La parte dedicata al circuito di segnale ha invece il compito di ricevere gli impulsi in uscita dal tubo Geiger, adattarli ed inviarli al microcontrollore che avrà a sua volta il compito di contarli.
Il compito di Arduino
Arduino una volta collegato alla scheda, dovrà essere programmato per poter ricevere i segnali ricevuti dal contatore Geiger, conteggiarli e produrre una misura che possa poi essere utilizzata per valutare il grado di radioattività presente nel luogo di misura.
Gli impulsi verranno raccolti per un periodo di 10 secondi, il quale verrà poi moltiplicato per 6 in modo da simulare il numero di impulsi per minuto (cpm – counts per minute). Una volta ottenuto questo valore, il cpm verrà diviso per un fattore di conversione unico per ogni tipo di tubo Geiger utilizzato. Questo valore si può trovare sui datasheet forniti dal produttore del tubo Geiger. Otterremo così il valore della radiazione che si misura in µSV/h (micro Sievert per ora) mediante il seguente calcolo.
cpm * conversion factor = μSv/h
LCD Screen
Insieme alla scheda shield viene fornito uno schermo a cristalli liquidi (LCD screen) a cui sarà connesso attraverso una linea a 4bit ( 4 linee di dati, oltre alle linee di controllo RS, Enable e RW). Su questo schermo visualizzeremo i valori di CPM e la lettura della radiazione presente in µSV/h .
Cosa è un Tubo Geiger e come funziona
Ma il vero cuore di tutto è il tubo Geiger-Muller connesso ad un lato della scheda. Questo tubo di vetro (o anche di metallo) viene riempito da un gas inerte come elio, neon o argo e portato a basse pressioni (circa 0.1 atm). All’interno del tubo vi sono due elettrodi tra i quali viene posta una differenza di potenziale di parecchie centinaia di volts. Uno degli elettrodi è costituito da un filo che passa al centro del tubo (anodo), mentre l’altro elettrodo è costituito dalla superficie interna del tubo, spesso rivestito da un materiale conduttore (catodo). La struttura interna del tubo è creata in modo da non permettere alcun passaggio di corrente.
La radiazione presente nell’ambiente attraversa la superficie del tubo e grazie al suo potere ionizzante, alcune molecole o atomi del gas inerte vengono ionizzati creando ioni carichi positivamente ed elettroni. La grande differenza di potenziale tra i due elettrodi costituisce un fortissimo campo magnetico che accelera gli ioni verso uno degli elettrodi (a seconda della sua carica). Lungo il percorso gli ioni urtano con altre molecole ionizzandole a loro volta, creando un flusso di ioni a cascata. Questo flusso a contatto con gli elettrodi produrrà un impulso di corrente che verrà rilevato dalla scheda e poi trasformato in un conteggio.
Il tubo Geiger utilizzato per questo particolare shield è il modello J305ß, realizzato per essere sensibile sia alle radiazioni beta che gamma. Inoltre viene scelto proprio per il suo prezzo contenuto e le sue piccole dimensioni (11 cm di lunghezza). Per calcolare il valore di radioattività, il fattore di conversione è 0.008120.
Altre componenti sulla shield board
Tutti noi conosciamo dalla TV i contatori geiger, che si riconoscono da quel crepitio che sta ad indicare i conteggi effettuati. Maggiore è il crepitio, maggiore sarà il livello di radiazione rilevata dall’ambiente. Per ottenere questo suono, è stato inserito sulla scheda un Piezo speaker che emetterà un suono per ogni impulso rilevato, indipendentemente dal controllo di Arduino.
Inoltre, sempre sulla scheda è presente una barra LED composta di 5 LED standard, 3 verdi e 2 rossi. Questi LED vengono controllati direttamente da Arduino a cui sono collegati da una serie di resistenze. Ecco lo schema:
| LED green 0 | PIN 9 digitale |
| LED green 1 | PIN 13 digitale |
| LED green 2 | PIN 12 digitale |
| LED red 0 | PIN 11 digitale |
| LED red 1 | PIN 10 digitale |
Inoltre esiste un interruttore sul bordo della scheda shield con due posizioni ON e OFF.
Tipologie di Radiazione
Raggi alfa
I raggi alfa consistono di particelle caricate positivamente (+2) emesse direttamente dal nucleo di un atomo radioattivo in decadimento. Queste particelle sono molto dense e pesanti e quindi sono in grado di propagarsi nell’ambiente solo per pochi centimetri (in presenza di aria) e non riescono ad oltrepassare anche le più semplici barriere. In genere questo tipo di radiazione non è molto preoccupante, a patto che la sostanza radioattiva che li generi non venga ingerita o iniettata all’interno del corpo umano.
Raggi beta
La radiazione beta consiste di particelle cariche negativamente (-1) emesse da un atomo radioattivo in decadimento. Queste particelle sono più piccole e leggere e sono in grado di penetrare per qualche millimetro all’interno di metalli. Sono quindi molto dannose per i tessuti viventi a cui vengono esposti.
Raggi gamma
La radiazione gamma rappresenta la parte a più alta energia dello spettro elettromagnetico (lo stesso delle onde radio, del visibile, degli infrarossi, ecc..). Questi raggi ad alta energia sono in grado di penetrare qualsiasi cosa. Solo i metalli più pesanti e densi sono in grado di schermarli o almeno attenuarli, come il piombo. I raggi gamma vengono prodotti naturalmente dal sole per arrivare sulla crosta terrestre come “raggi cosmici”. Questa radiazione è molto pericolosa.
La radiazione ambientale
Abbiamo visto come nella nostra atmosfera possano arrivare le radiazioni sotto forma di raggi cosmici. Ma questa non è la sola forma di radiazione naturale a cui siamo sottoposti quotidianamente. Esistono infatti nel suolo molti materiali radioattivi che producono una delle tre tipologie di radiazione viste in precedenza, durante il processo di decadimento degli atomi. I minerali radioattivi più noti a tutti sono quelli a base di Uranio, ma esistono molti altri elementi, ed isotopi radioattivi presenti nei minerali della crosta terrestre.
Siamo quindi sempre sottoposti ad una radiazione di fondo. Questa varierà a seconda della nostra area geografica, dall’altitudine e da molti altri fattori. Una radiazione di fondo o ambientale comune va da valori di circa 3650 – 7200 μSv per anno.
Ma quali sono i valori che possono produrre problemi alla salute? Per prima cosa è importate specificare che bisogna tenere conto non solo dell’intensità della radiazione, ma soprattutto del tempo di esposizione ad essa. Per questo motivo è stato stabilito che il valore limite di radiazione assorbita in un anno deve essere inferiore ai 50000 μSv ( circa 10 volte superiore al livello di radiazione ambientale). Quindi se non esposti a sostanze radioattive, non abbiamo di che preoccuparci. Considerate che una lastra a raggi X non supera i 100μSv.
Connettere insieme il tutto
Prendete il tubo catodico fornito e saldate i due connettori alle estremità alle due posizioni forate vuote sulla scheda. Una volta ben saldato, bloccate con due fascette il tubo Geiger alla scheda per tenerlo bloccato. A tal proposito ci sono due fori in corrispondenza sulla scheda shield.
La scheda Arduino farà da base allo shield (Radiation board) che verrà inserito occupando quasi tutti i pin. Per alimentare tutto il contatore Geiger sarà sufficiente utilizzare il pin a 5V presente su Arduino. Mentre gli inpulsi in output dalla scheda verranno ricevuti come interrupt 0 sul PIN 2 digitale. Poi sopra lo shield inseriamo la scheda con lo schermo LCD integrato, utilizzando i pin già predisposti nel lato superiore.
Codice sorgente
Vediamo insieme il codice sorgente:
/*
* ------Geiger Tube board (Arduino Code) Example--------
*
* Explanation: This example shows how to get the signal from the Geiger Tube
* in Arduino, we use one of the Arduino interrupt pins (PIN2).
* We count the time (ms) between two pulses of the Geiger tube.
*
* Copyright (C) 2011 Libelium Comunicaciones Distribuidas S.L.
* http://www.libelium.com
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Version: 0.3
* Design: Marcos Yarza, David Gascon
* Implementation: Marcos Yarza
*/
// include the library code:
#include <LiquidCrystal.h>
// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(3,4,5,6,7,8);
// Threshold values for the led bar
#define TH1 45
#define TH2 95
#define TH3 200
#define TH4 400
#define TH5 600
// Conversion factor - CPM to uSV/h
#define CONV_FACTOR 0.00812
// Variables
int ledArray [] = {10,11,12,13,9};
int geiger_input = 2;
long count = 0;
long countPerMinute = 0;
long timePrevious = 0;
long timePreviousMeassure = 0;
long time = 0;
long countPrevious = 0;
float radiationValue = 0.0;
void setup(){
pinMode(geiger_input, INPUT);
digitalWrite(geiger_input,HIGH);
for (int i=0;i<5;i++){
pinMode(ledArray[i],OUTPUT);
}
Serial.begin(19200);
//set up the LCD\'s number of columns and rows:
lcd.begin(16, 2);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Radiation Sensor");
lcd.setCursor(0,1);
lcd.print("Board - Arduino");
delay(1000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" Cooking Hacks");
delay(1000);
lcd.clear();
lcd.setCursor(0,1);
lcd.print("www.cooking-hacks.com");
delay(500);
for (int i=0;i<5;i++){
delay(200);
lcd.scrollDisplayLeft();
}
delay(500);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" - Libelium -");
lcd.setCursor(0,1);
lcd.print("www.libelium.com");
delay(1000);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("CPM=");
lcd.setCursor(4,0);
lcd.print(6*count);
lcd.setCursor(0,1);
lcd.print(radiationValue);
attachInterrupt(0,countPulse,FALLING);
}
void loop(){
if (millis()-timePreviousMeassure > 10000){
countPerMinute = 6*count;
radiationValue = countPerMinute * CONV_FACTOR;
timePreviousMeassure = millis();
Serial.print("cpm = ");
Serial.print(countPerMinute,DEC);
Serial.print(" - ");
Serial.print("uSv/h = ");
Serial.println(radiationValue,4);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("CPM=");
lcd.setCursor(4,0);
lcd.print(countPerMinute);
lcd.setCursor(0,1);
lcd.print(radiationValue,4);
lcd.setCursor(6,1);
lcd.print(" uSv/h");
//led var setting
if(countPerMinute <= TH1) ledVar(0);
if((countPerMinute <= TH2)&&(countPerMinute>TH1)) ledVar(1);
if((countPerMinute <= TH3)&&(countPerMinute>TH2)) ledVar(2);
if((countPerMinute <= TH4)&&(countPerMinute>TH3)) ledVar(3);
if((countPerMinute <= TH5)&&(countPerMinute>TH4)) ledVar(4);
if(countPerMinute>TH5) ledVar(5);
count = 0;
}
}
void countPulse(){
detachInterrupt(0);
count++;
while(digitalRead(2)==0){
}
attachInterrupt(0,countPulse,FALLING);
}
void ledVar(int value){
if (value > 0){
for(int i=0;i<=value;i++){
digitalWrite(ledArray[i],HIGH);
}
for(int i=5;i>value;i--){
digitalWrite(ledArray[i],LOW);
}
}
else {
for(int i=5;i>=0;i--){
digitalWrite(ledArray[i],LOW);
}
}
}