Non ci sono prodotti a carrello.
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
Codice Contatore Geiger
1 file(s) 3.70 KB
Per il download di questo file รจ necessario essere registrati al sito
Download del Gerber per contatore Geiger
Gerber per contatore Geiger
1 file(s) 102.77 KB
Per il download di questo file รจ necessario essere registrati al sito
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โฆ