Introduction: Networked Radiation Detector: Feel Cosmic Rays on Your Fingertips
*Update (12/23)*: Just entered the "protected" competition- protect yourself from radiation and vote for me :) Thanks
Note: This is my very first Instructable! I will be very responsive to feedback on how to improve the project description below, so please let me know.
In this tutorial, you will learn how to build a device that lets you feel radiation in your vicinity on your fingertips, and, if tuned well, feel cosmic rays passing through your hands. You will build it starting only with Geiger Muller tubes, fairly standard electronics components, and RFDuinos. The basic steps are to create a high voltage supply in which to suspend your tubes, process pulses from your tubes and feed them into an RFduino, and then use RFduino's GZL library to radio events to a glove with vibrating motors attached to the fingertips. (RFDuino also makes it very easy to read data into an iPhone app, if you feel like going further). If you'd like to read through a journal I kept while working on the project, it is available here
I'm writing this tutorial for people like me: you are still somewhat of a beginner in electronics, but do have some exposure. You have studied physics or at least have a keen interest in physics detector design. You believe that allowing people to sense physics phenomena that we normally cannot is a way to make others care about the study of physics. I'll try my best to walk through steps slowly.
- Approximate Cost: $100-$150 (There are probably some shortcuts to make it cheaper)
- Prerequisite: Basic knowledge of electronics components (resistors, capacitors, inductors, '555 timers, microcontrollers)
- Prerequisite: Circuit Layout in Eagle (or follow a separate tutorial to learn)
- Prerequisite: Interest in building your own physics detector without using a prefabbed circuit
- Prerequisite: Access to a fab lab. In particular, access to Modela for circuit milling, and ideally a laser cutter and Shop Bot for case building
You could also build the circuitry on a breadboard and bypass the need for access to a fab lab/circuit layout in Eagle.
Step 1: Quick Peak at Complete Geiger Schematic
We'll walk through each chunk in the following steps...this image does not include the glove circuitry yet. I've also attached the Eagle file in step 1 which you can download and view more closely.
General Note: Any 0-ohm resistors in this circuit were added purely for the purpose of routing my board (since I was just milling a single sided board). They can readily be omitted if you route your board differently.
Step 2: Understanding the Geiger Tube Circuit and Building a High Voltage Supply
First, you need to acquire some Geiger-Müller Tubes (at least 2 if you'd like to build a cosmic ray detector). I chose the SBM 20 tubes for $25 each because I could order them off of Amazon, but if you're willing to take a chance on Ebay, you can get similar tubes in the $10-$20 price range. Fun fact: I read that a lot of these tubes were created by the Soviet Union during the Cold War.
At a high level, Geiger-Müller Tubes work as follows: the tube is filled with an inert gas like Helium and Argon (These are examples of noble gases that are unlikely to undergo reactions). When an incoming high energy particle entires the tube, some of the gas may be ionized. At least a few hundred volts are applied across the tube, and the resulting electric field (remember that electric field is a function of applied voltage) causes positive ions to move towards the cathode of the tube and free electrons to drift towards the anode. As these ions and electrons move, if the electric field is strong enough, they will cause further collisions and therefore further ionization events in the tube. The ionization of the gas lasts on the order of a few microseconds, and when the electrons reach the tube's anode wire a current pulse (which in our case we measure as a roughly 1.5 volt pulse) we can process the resulting signal as a hit. At this point the there is a high positive charge near the anode (due to the positive ions that have accumulated there). This weakens the electric field and the avalanche of ionizations will terminate. The tube will settle back into its initial state until another incoming ionization particle sets off an avalanche again.
(note: avalanche image from http://en.wikipedia.org/wiki/Townsend_discharge)
We need to provide the GM tube with a high voltage across its anode and cathode for this process to kick off. To do so, I'll use boost converter circuitry that I found here. (You can see my relevant circuitry in an included image on this page). The '555 timer is wired in astable mode such that it outputs pulses at it's Q output pin. C1, D1, R1, and R2 all control the amplitude of the pulses, but for our application I don't believe that the values you select will matter too much. Whenever the '555 timer outputs a positive pulse at Q, the transistor Q2 attached to Q will turk on, allowing current to flow through the inductor. At a certain point, the voltage at Q1's gate will rise enough to turn Q1 on. When Q1 turns on, the reset pin of the '555 will be triggered (note that it is active low). This causes the output at Q to go low, which causes Q2 to shut off. When Q2 shuts off, the inductor will do what inductors do: attempt to maintain the current that was previously flowing through it. The voltage across the inductor will spike, and a burst of current will flow through the inductor, through diode 2 (the diode prevents any current from flowing backwards and damaging the inductor) and into C2, where a high voltage will accumulate. R5 is a potentiometer. The one that I chose ranges from 0 to 100 ohms. The value of R5 determines the point at which Q1 is turned on, which in turn determines how much current the inductor will seek to preserve and therefore how big a voltage spike it will experience. In summary, the potentiometer's value determines what voltage level you will achieve. If you follow my circuit exactly, you should be able to range from about 30 volts to 500 volts stored in C2.
Note: Instead of using a '555 timer (which my professor called outdated), you could instead use an output pin of a micro-controller to provide pulses (PWM).
It is important that any parts that will be exposed to high voltage are rated appropriately. Here are the key components I used for the HV supply and their Digikey listings.
'555: LMC555CMX ($1.07 each)
Diode D2: 641-1018-1-ND (1 KV, 1 Amp) ($0.27 each)
HV Capacitors (C2, C3): 709-1039-1-ND (1 KV) ($0.48 each)
Inductor: 445-3823-ND (10 MH, 410 mA, 3.41 Ohm) ($3.02 each)
Potentiometer: CT2154-ND ($5.34 each)
The other resistors, capacitors, and diodes hooked to the '555 will not be exposed to high voltage and therefore you can use more off of the shelf components.
Some important notes on debugging:
The current flowing to the GM tubes is extremely small. If you attempt to measure the voltage after the diode with a standard multimeter or oscilloscope, your multimeter/oscilloscope will load the circuit and you will not be able to detect the high voltage! I got around this by measuring *before* D2. There is a lower impedance at this point of the circuit and therefore you will be able to see the high voltage on a standard oscilloscope. Another approach would be to get a very large resistor (on the order of 1 Giga-ohm and place it in series with your oscilloscope).
When debugging, start with the potentiometer turned to its lowest value, and then slowly turn it and watch the resulting voltage. If there is a point at which the voltage suddenly drops down again, it could be that one of your parts is failing (double check that everything is soldered well and that your components are rated for high enough voltage and current). It could also be that your measuring device is still loading the circuit too much.
Next, we'll wire up the tubes to the HV supply!
Step 3: Attach Your GM Tubes to the HV Supply You Created
Next, check what the anode resistor rating is for your tube. For the SBM20 tube, 20 MegaOhms is recommended. This resistor limits the current through the tube and therefore is generally very high. I've split my resistance among 4 250K resistors (R7, R8, R9, R10) in order to limit the voltage drop across each one (since my resistors are not rated for high voltages). If you have high voltage resistors you could just use a single one. R11 is optional, and is meant for safety) (Actually I ended up removing mine in the end.) When you switch power off, a large voltage will remain stored in C2/C3. It will leak off slowly based on the cap's leakage properties, but R11 will drastically speed up the leakage. On the bright side, this means that there is less risk of shock/injury if you were to touch the circuit a few seconds after shutting off power. On the negative side, this resistor reduces the voltage stored in the capacitor. You might consider choosing a value significantly higher than 1M if you do choose to include it as a safety precaution. I am not sure of the purpose of R6, but it was included in my reference schematic (cited in the previous step) so I included it as well. I then include two separate 2x2 SMD connectors to attach to the anode and cathode of my tube:
NOTE: I used 2x2 connectors because that is all that I had. Really, you just need two 2x1 connectors (one for each of your two tubes). Also, you could in theory just use a single 2x2 connector for the two inputs and two outputs of your tubes, but I chose to separate them since my tubes would be in a case and the wires could be attached more easily this way.
If all goes well, you should be able to see the pulses at the output of the tube on your oscilloscope as in the image above. These pulses should look pretty clean, and represent hits!
Step 4: Feeding Tube Output to RFDuino
Next, you connect the cathode of your tube to the micro-controller (in our case, the RFDuino).
A few notes:
- regardless of the energy of your incoming radiation particle, the output pulse will look the same
- the RFduino runs on 3.3 volts, whereas the '555 required 5 volts. Therefore, you can see on the complete schematic that I posted that I used a 3.3 volt regulator (wired with a few capacitors as the regulator's data sheet suggests) in order to obtain the necessary 3.3 volt signal. I've labeled this as 3.3V, but maybe ought to have used Eagle's supply symbol)
- R16 and R17 act as a voltage divider, determining the output threshold that you consider a signal. You can play with these values a bit, but since the signal to noise ratio on these tubes is so significant, I don't think the values will matter too much. R31 is current limiting, and C4 acts as a bypass (decoupling) capacitor, reducing overall noise
How this works:
Geiger1 is connected to the cathode of the tube (the 400 volt drop occurs across the tube, so this chunk of circuit is at low voltage again). Any time a small current burst occurs across the tube (as a result of the avalanches described earlier) Geiger1 will attain a voltage, and cause current to flow through R16/R31 and turn on the transistor Q3. When Q3 is on, then RFGeiger1 goes low, causing the port pin on the micro-controller to go low.
Step 5: Hooking Up RFDuino
RFDuinos very easy to work with! They come in different flavors, but I use the simple surface mount component without any of the shields. There are some Eagle libraries floating around with the RFDuino footprint included (try here, for example)
RFDuino very easy to program serially without dropping cash on the USB shield..all you need is an FTDI pinhead and an FTDI to USB cable. Then, you can hook RESET to RTS (.1uF capacitor in series required) P0.00 to TX, and P0.01 to RX, (TX and RX are 'transmit' and 'receive', used to send and receive data from the computer to the chip.) I have chosen to power my device from an external power supply, and so I have not hooked up the power pin of the FTDI cable. If you'd instead like to power from your computer, you can hook the power pin to your 5 volt line (don't forget that RFDuino runs on 3.3V so you need to make sure the computer's 5V is regulated to 3.3V first!).
Next, connect all RFDuino pins labeled 'Ground' to ground, your 2 geiger tube signals to port pins, and you're already in a position to program your RFDuino! (well, I also connected two additional port pins to LEDs, which are driven via MOSFETs. Resistor values depend on the LEDs that you are working with).
Design note: there is no particular reason why I use MOSFETs for driving LEDs and 'normal' transistors elsewhere. Either can be used to drive components...just remember that MOSFETs require a much higher voltage at the gate to turn on, whereas transistors only need a small voltage (whenever base is .65 volts greater than emitter). In the picture, you can see one of my LED's lit up, one of the first hits that the LED revealed :)
Step 6: General Notes on Building the Circuit
- Layout schematic in Eagle. Eagle is very fussy about how you draw your lines, so make sure to use Eagle's "design check" feature (see a different tutorial to learn how)
- Layout board in Eagle (I have found that manual routing is actually more efficient than Eagle's auto-routing feature, at least for single sided, hand-milled boards like the one I built). But it's still pretty hard work...this board took me 4 hours to layout. Then again, I'm still relatively new at this!
- Note: You will be milling traces with 1/32'' end mill (assuming you use the same techniques that I used) and so you need to make sure that your traces are far enough away from one another. You can check this by using Eagle's "Design Check" feature while laying out your board. Follow a different tutorial to learn how to adjust and run the design check.
- Note: Either you will need to patiently create footprints for all of your components, or you will need to consult the datasheets of the components you are using and find components in the Eagle library with similar footprints. I chose to do the latter.
Step 7: Programming the RFDuino
RFDuino is pretty damn easy! Follow the RFDuino quickstart guide to get set up within the Arduino IDE (note: you need version 1.5.8 of the IDE). The IDE comes with lots of sample programs, some of which use Bluetooth Low Energy and other that use GZL (BLE is great for talking to an iPhone app, and GZL a networking protocol for which RFDuino has built a library and is great for communicating between RFDuinos). You can see a snippet of my code here, where I check whether there is a simultaneous hit and change the LED port pin states accordingly (NOTE: in my current implementation, I never get simultaneous hits. You'll need to play around with lengthening the time window in order to actually get simultaneous hits registered. I think it has something to do with the delay in the tube? But I don't really know why I never got simultaneous hits as is. I definitely detect radiation though, as the count rate doubles when a radiation source is nearby).
Step 8: Making the Case
I modeled a case for my two tubes in Solidworks and milled it out of thick, clear acrylic using a Shop Bot. You can be creative and make whatever case you'd like, as long as you leave space for the wires to come through! I ended up doing a two-part case that I glued together and sealed with some decal stickers that I printed. To attach the wires to the tubes I used fuse clips (NOTE: take a tool and pull apart the fuse clips a bit before sliding onto the tube's ends...otherwise you're at risk of damaging the tubes). I then soldered my wire onto the fuse clips.
I laser cut a small holder out of acrylic and used copper tape underneath the acrylic so that I could more cleanly glue my LEDs to the case.
Step 9: Radiation-Sensitive Glove
You're almost there! Next is the fun part- making a glove that will vibrate whenever a radiation particle is detected in the tubes. Again, lots of room for creativity once you have the circuit up and running. You'll make a brand new circuit for the glove and attach small vibrating motors.
The circuit schematic is above. It consists of another RFDuino, another FTDI connector for programming, another 3.3V regulator, and finally 3 MOSFETs for driving the motors, with pads to attach the motors. Note: When laying out the board, thing about placing your pads strategically so that they are near the fingers that you would like the vibrators on.
Design, layout, mill, and stuff the board, then attach to a glove with hot glue. In this very simple GZL network, your glove is your 'device' and your detector is your 'host'. The device is responsible for pinging the host repeatedly to check if new information is available, and if it is, the host will send the device the information, which can be read. In my case, I have different integers being sent based on whether tube A, tube B, or both tubes are hit, and I vibrate different fingers accordingly. Again, be creative! I think a cool next step in this project would be to think about what a radiation particle ought to feel like, rather than just an arbitrary buzz.
(note: image above is an earlier iteration I made with 5 vibrating motors. Made a version with only 3 for the final)
Step 10: Wrapping Up
You now have all the pieces in place to make a device that lets you feel radiation on your fingertips! I made the remainder of my circuit casing out of press-fit, laser cut acrylic and called it a wrap.
If you can acquire a radiation source (such as the one taped to the side of the professionally manufactured geiger counter in the photo above) then you can confirm that you are actually measuring radiation particle hits. In my case, count per minute more than doubled with the source nearby
This is my first Instructable, so I will be very responsive if there are additional useful details I can provide, or if anyone has tips on how to improve the project. Let me know! Happy building.
Participated in the