Scintillino - an Arduino-based Quick&dirty Scintillation Counter

40,086

123

18

Posted

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

All of it together and clicking away...

Get creative and make it look nicer. You could put it in a box, add custom decorations... 
Now go measure radiation to your heart's content!


Leave a comment on your experience making this project!

thanks,
Rok & Matjaz
JSI and PhysEng

Share

  • This was a lot of fu...-door144

    door144 made it!

Recommendations

  • Epilog Challenge 9

    Epilog Challenge 9
  • Sew Warm Contest 2018

    Sew Warm Contest 2018
  • Gluten Free Challenge

    Gluten Free Challenge
user

We have a be nice policy.
Please be positive and constructive.

Tips

Questions

16 Comments

Could you please provide a quote for the price of the SiPM and scintillator? so that we can compare with other options.

Also, you should NOT use the interrupt that way... each interrupt call takes at least 80 cycles, probably more: http://forum.arduino.cc/index.php?topic=157135.0

Your maximum frequency will be CPU/80=200 Kcps (VERY optimistic!!). Use the T1 pin as external clock input for Timer1, so that you can read up to CPU/2.5= 6 Mcps.

Also, even if you don't have so many cps, with your code many pulses will be "missed" during the processing of the previous one and the value you obtain may not be reliable (unless you are VERY below the maximum, so up to 1 Kcps is ok).

Read here http://forum.arduino.cc/index.php?topic=166902.0

Why do you need two stage discriminator? Why cant it be simple one rail2rail op-amp?

Hi, actually, you don't need to bring 3V3 to power the op-amp. I fixed my comment on the schematic. 5V pin could be able to give you more current if the 3V3 onboard regulator cannot. See if this helps... and ask again until we get it working for you! :)

BTW, do you have any oscilloscope available for debugging this?

can you help me out with building the discriminator and biasing circuits? There is no description here on how to build those. Which parts will I need?

Hi, sorry for my replying so late - haven't figured out yet how to set alerts based on comments here. :)

The full schematics of the discriminators and the biasing circuit are described in step two. Can you please tell me exactly what part of that you need help with? The functions of the various circuit parts or the implementation - i.e. soldering and stuff?

Im having trouble getting the right SIPM I have a PM1150 but it has 4 outputs and is really small. What did you use? Do you know where I can buy one I really want to make this project. Im also having trouble following the steps on how to build the discriminator?

My diode was a PM3350. I cannot find Ketek's documentation for your PM1150 on their web site, but in principle it should work for you. Maybe ask Ketek for a datasheet? Then we can figure out the connections.

Anyway, SensL and Ketek would both definitely sell you one if you want. For one piece, they probably would ask between $50 and $150.

Ok I know im driving you crazy lol. The image is what I built so far. the issue im having is 3.3v VCC or the gold wire looks to be shorting out the arduino. Also where does the out- go on the DC DC step up? Is there any way I can have more photos :P

1.JPG

I love this, and think everyone should have one running 24/7 near their computer, or wherever they spend most of their day. Knowing the exact moment you're being exposed to a nuclear event, could help you minimize exposures, and save lives. That is a good thing in this era of "dirty bomb" threats. But since there are (2) high priced components (as you mentioned), I think you would be better off buying a $25-$50 Civil Defense 1950's era radiation detector, and wiring it to a 12 v. power supply so it could run 24/7, without the batteries. It would also allow you to distinguish between, Gama, Beta, and Alpha sources that have contaminated your home's air, with an audible alarm, and analog needle reading showing exact background levels. Just a thought on a cheaper way to do it. Also, I'm told smoke detectors use a radioactive source & detector (which is modulated by visible smoke). Could a smoke detector offer a cheaper source for your detector circuit??? Just wondering?