Introduction: Scintillino - an Arduino-based Quick&dirty Scintillation Counter
Have you ever wondered about the radiation levels around you? Well today you can build your very own detector that measures ionizing radiation and displays data in real-time on an LCD (and also your computer if you want).
The visual design, as seen below, is perhaps a tad short of a Red Dot Award, but it sure works fine. It is a scintillation counter, no less and no more.
In fact, the game was all about doing it with the least amount of effort and nearly no budget, given that we already had a small scintillation crystal (LYSO) and a Silicon photomultiplier (SiPM) at hand. (Those were the only two expensive parts, at roughly $100 each. Sigh... We know...).
Our scintillator was supplied by Andy of http://pjtelect.com/. The SiPM is a KETEK one because they have a low breakdown voltage of 25V which makes it really cheap to bias them at around 30V....
What you will need:
- a scintillator crystal (we used a 1cmx1cmx2cm LYSO (Lu2Si2O7:Ce3+) but most any scintillation material should do)
- a Silicon photomultiplier (we prefer that over a PMT because HV biasing is easier and they are also harder to destroy)
- resistors, capacitors
- two fast rail2rail op-amps
- a simple DC-DC step-up converter off eBay
- a piezo buzzer for added dramatic effect
- Arduino Uno board
- LCD Keypad Shield (or another LCD, with minor adjustments to the Arduino sketch)
- soldering iron and tin (we use, lovingly, the old school non-ROHS stuff that will kill you etc etc yada yada)
- cardboard (for the motherboard), nylon ties
- a bunch of wires
- something to hold your SiPM tight against your crystal (we drilled holes into a scrap piece of thick plastic)
Now let's get started!
Step 1: Setting Up the Scintillation Detector
Scintillators work by eating up a gamma-ray and then emitting a burst of several thousand photons of visible light within the next few nanoseconds. This meagre amount of visible light is detected by a Silicon photomultiplier and converted into a pulse of electrical current.
To measure light flashes this dim, we must obviously prevent any daylight from entering the detection chamber. For this reason we've constructed a cardboard box to enclose it.
Inside, we used a machined piece of thick plastic (because we had it, but duct tape or transparent epoxy would do, too) and some upholstery foam to press the scintillation crystal against the SiPM. You want good optical coupling here. The faces of the scintillator that are not facing the SiPM are wrapped in white teflon tape (yes, plumbing tape from HW store) to reflect as much light as possible toward the SiPM.
The top half of the box is a bit larger to fit over the bottom half. Make V cuts on both the bottom and the top half (as seen on the picture), so that you will be able to route the cables out of the box.
Tip: Depending on which you do first, the plastic or the box, make sure that the latter will fit the former.
Cover the scintillation thing with aluminium foil before closing the box. This will help keep out stray light....
... and your detector is ready!
Step 2: Some Very High-fidelity Nucleonics Comin' This Way...
Front-end electronics.
The left side is the basic plain vanilla SiPM biasing circuit. Powered at 30V through the 10k resistor, with the ultra-fancy transimpedance stage being the 47ohm at left bottom. This is capacitively coupled to a two-stage discriminator that fires when the input pulse is large enough. Any fast rail-to-rail op-amp will do, and so does OPA2354 by Texas.
The hard part was soldering the darn smd package by hand to an old DIL socket. A shot of Gin steadied the hand and then all went well.
Ugly? Yes.
Works? Absolutely.
Step 3: DC-DC Step-up Converter 5V to 30V
An LM2577 DC-DC adjustable step-up board. $3 off eBay from seller BuyInCoins.
Solder a wire to each end of the IN side (IN+ and IN-) and connect them, respectively, to 5V and GND of Arduino.
Similarly for the OUT side, the "minus" is the same as IN-, and OUT+ is the 30V "HV" bias for the photosensor.
Turn the screw on the blue multi-turn pot to get to 30V output.
Step 4: Programming the Arduino Board
For this step I'll assume that you already have Arduino IDE installed. (if not, you can check out http://arduino.cc/en/Guide/Windows on a tutorial on how to do just that.
Upload the code below to the Arduino board, mount the LCD screen.
Note: We're using an "eBay LCD keypad shield" with pinout defined as lcd(8, 9, 4, 5, 6, 7).
If you're using another LCD, you might need to adjust the LCD connection pin numbers in the code.
This is the code we used:
#include <LiquidCrystal.h> // includes necessary library
int INPIN = 2; // input pulses on pin 2
int buttonPin = A0; // input button on pin A0
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // connections to LCD
int OUTPIN = 3; // output pulses on pin 3
volatile long int numint = 0; // counter for input pulses
int safevalue =500; // initial value of number of pulses considered safe
void intservice(void) // this is called for every input rising edge
{
numint++;
}
void setup() {
pinMode (buttonPin, INPUT);
pinMode(INPIN, INPUT);
pinMode (OUTPIN, OUTPUT);
digitalWrite(OUTPIN, HIGH);
digitalWrite(INPIN, LOW);
attachInterrupt(0, intservice, RISING); // attach interrupt routine
lcd.begin(8,2);
lcd.clear();
Serial.begin(9600);
}
void loop() {
int avalue;
lcd.setCursor(0, 0);
lcd.print(numint); lcd.print("cps"); lcd.print(" "); //print number of pulses in counts per second(cps)
lcd.setCursor(0,1);
avalue= analogRead(buttonPin); //variable for button input
if (120<avalue && avalue<150 &&(safevalue >=0 && safevalue < 1000)) {safevalue=safevalue+100; goto finish;} //upon pressing the up button, safevalue increases by 100 while lower than 1000
if (270<avalue && avalue<320 &&(safevalue > 0 && safevalue <= 1000)) {safevalue=safevalue-100;} //upon pressing the down button, safevalue decreases by 100 while lower than 1000
if (120<avalue && avalue<150 &&(safevalue >=1000 && safevalue< 10000)) {safevalue=safevalue+500;} //upon pressing the up button, safevalue increases by 500 while higher than 1000, up to 10000
if (270<avalue && avalue<320 &&(safevalue > 1000 && safevalue<=10000)) {safevalue=safevalue-500;} //upon pressing the down button, safevalue decreases by 500 while higher than 1000
finish:
lcd.print(safevalue); lcd.print(" "); //prints current safevalue
numint=0; // zero counter
delay(1000);
if (numint > safevalue){digitalWrite(OUTPIN, LOW); // beeper beeps if pulse count is higher than allowed
delay(10);
digitalWrite(OUTPIN, HIGH);
}
else {digitalWrite(OUTPIN, HIGH);}
Serial.println(numint); // print pulse count to serial
}
This code programs the Arduino to count gamma-rays (or other energetic stuff that dumps at least some 20keV at a time in the crystal) detected by the scintillation detector, in counts per second (cps). It will also send a signal to the beeper (that we will be connecting in the next step) if the value is higher than a selected "safe" cps level. You can change the preset safe value by pressing the up/down button on the LCD Keypad Shield. Events can also be monitored an a computer via a serial monitor when the Arduino board is connected to the PC via a USB cable.
Note: We will be using a USB cable to power the Arduino. If you want to make the whole thing portable, follow these instructions to power the Arduino from a battery, or simply buy a soldered one online.
Step 5: Connecting the Beeper - the Cool Part That Annoys the Office...
Again a $2 eBay purchase.
Connect ground to ground (gnd) on Arduino, vcc to voltage (5V) and I/O to pin number 3. It's an active buzzer that only needs a pin pulled low (no bit-banging) to beep.
The code is written such that it will chirp every second if the CPS levels are above the set threshold.
Step 6: Putting It All Together
