Geiger Müller Counter

This Geiger Müller counter (GM counter) is made with a small GM tube bought from a seller in Ukraine. Most GM counters use longer tubes that are probably more sensitive than this one, but this one works fine and you can point it at things that you think may be radioactive.

Spoiler, I couldn't find anything in or around my house that was radioactive, except for an old smoke detector. Old smoke detectors used a tiny bit of Americum 241 (less than a microgram!) to detect smoke particles. New smoke detectors all work with optical sensors. But is was enough to test my detector.

The cup with the Americum is mounted on top of a broken headphones audiojack, so you don't have to come very close to the radioactive material.

the code can be found here:

https://gitlab.com/WilkoL/geiger-mueller-counter

Geiger Müller Tube

ATTINY2313

MPSA42 (high voltage NPN transistor)

GP02-40 (high voltage diode)

Capacitor 22 nF 1 kV (high voltage)

2 x BC549 (general purpose NPN transistor)

10 mH inductor (ferrite core)

some resistors and capacitors and a red led

speaker

analog meter (max 10 mA)

The working of this counter is very simple. A high voltage is generated and applied to a GM tube. When a radioactive particle hits the gas inside the GM tube it conducts a short time. The current that flows through it is amplified and counted with a microcontroller. The number of particles that it counts in one second is then displayed on a meter.

An ATTINY2313 is used to produce a squarewave that opens and closes a transistor. When the transistor conducts current it flows through an inductor, building up a magnetic field. As the transistor closes, this inductor tries to keep this current flowing, but as the transistor now isolates, a high voltage develops over the inductor. With a diode this high voltage is stored in a capacitor and applied to the GM tube.

The high voltage is generated with a 50% squarewave that switches Q1 (MPSA42). This is a high voltage transistor and it might be hard to obtain. Any switching transistor that can handle a few hundred volts will do. This one is rated for 300V, which is enough for this GM tube.
Transistor Q3 is used to make Q1 close as fast as possible. When you turn off a transistor it always takes a little time, when you remove the charge in its base it will close a bit faster. Q3 takes care of that and is switched on about one microsecond before Q1 is turned off. (see oscilloscope screen)

Experimentally I found that this way it made Q1 close the fastest. And the faster you turn off the current through an inductor, the higher the voltage it generates. Two other parts may be somewhat difficult to obtain. The GP02-40 diode and a 22 nF, 1 kilo Volt capacitor. Again, any high voltage diode that is reasonably fast and any capacitor that can handle a few hunderd volt will do.

A GM tube normally is an isolator but when a particle enters it the gas inside the tube can be ionized making the tube conduct. A little current then flows though the tube, and another transistor (Q2) amplifies it. The signal from this transistor triggers an interrupt on the ATTINY2313 and is counted. The total amount of counts in one second is calculated and displayed on an analog meter. A red led also blinks at every count. Later I decided that it would be nice to have some clicking soun coming from the counter too, but the speaker I used doesn't produce much sound. You can hardly hear it.

The only part that is critical in the GM counter is this GM tube itself. I bought it via Ebay, it came from a seller in Ukraine and it is doubtful that you can still buy exactly the same one. You may have to buy two or three different tubes and experimentally find out which work best, it took me two tubes.

The code was written with Microchip Studio 7 (formerly Atmel Studio 7) for a ATTINY2313 in 20 pin DIP package.

The external interrupt INT0 is enabled.

TIM0 is initialized to produce the variable PWM signals for the analog
meter at 122 Hz. When you look at the Yellow signal in the oscilloscope image above you can see that it changes polarity. This way I could use a meter that has its zero in the middle of the scale. If you use a meter that only needs a positive current (most do) you can simply use one output channel of the timer and connect the other side of the meter to ground .

TIM1 does almost the same, but on 7 kHz, and both output signals are fixed and each others opposite (almost)

void init_peripherals(void)
{
    DDRB |= (1 << PB0) | (1 << PB2) | (1 << PB3) | (1 << PB4);
    DDRD |= (1 << PD5);
    
    MCUCR |= (1 << ISC01);                                    //generate interrupt INT0 on falling edge
    GIMSK |= (1 << INT0);                                    //enable interrupts on port INT0
    
    //TIM0 is used for 1 second timing and pwm for the analog meter
    TCCR0A |= (1 << COM0A1);                                //Clear OC0A on Compare Match, set OC0A at TOP
    TCCR0A |= (1 << COM0B1);                                //Clear OC0B on Compare Match, set OC0B at TOP
    TCCR0A |= (1 << WGM01) | (1 << WGM00);                    //FAST PWM, TOP is 0xFF, overflow interrupt set on TOP
    TCCR0B |= (1 << CS02);                                    //prescaler on 256
    TIMSK |= (1 << TOIE0);                                    //interrupt on overflow (122 Hz)
    
    //TIM1 is used for generating the pulses for the High Voltage generator
    TCCR1A |= (1 << COM1A1);                                //Clear OC1A on Compare Match, set OC1A at TOP
    TCCR1A |= (1 << COM1B1) | (1 << COM1B0);                //Set OC1B on Compare Match, clear OC1B at TOP
    TCCR1A |= (1 << WGM11);                                    //fast pwm, top = ICR1
    TCCR1B |= (1 << WGM12) | (1 << WGM13);    
    TCCR1B |= (1 << CS10);                                    //prescaler = 1    
    TCCR1C = 0;    
    ICR1 = 1100;                                            //freq circa 7000 Hz
    OCR1A = 600;                                            //dutycycle circa 50%
    OCR1B = OCR1A - 10;                                        //OC1B reacts approx 1 uS before OC1A
    
    sei();
}

There are two interrupt routines, one for handling the external interrupts on INT0 that are generated each time a particle is detected.
It increments the counts_per_second variable and takes care of flashing the LED (eagled eyed viewers will notice that this interrupt has a problem when there are more than 200 counts per seconds coming in :-) )

The other interrupt comes 122 times a second from TIM0 - overflow. This is used to make a 1 second signal.

ISR(INT0_vect)
{
    if (counts_per_second < 65535) counts_per_second++;     //particle detected
    
    PORTB |= (1 << PB0);                                    //flash led (and make small clicking noise)
    _delay_ms(5);
    PORTB &= ~(1 << PB0);
}

ISR (TIMER0_OVF_vect)                            //122 times / second
{
    static uint16_t counter = 0;
    
    if (counter != 0) counter--;
    else                                          //once per second
    {
        counter = 121;
        one_second = 1;                           //message to main
    }
}

The main routine loops and checks if the one_second variable is set. If it is it resets it, takes the log10 of the counts-per-second variable and resets that one to 1. It does not reset it to 0 because if there is no particle detected in the next second it would try to take the log10 of 0 and that is "illegal" (it would be minus infinity).
The log10 is averaged and used as the next value for the PWM signal to the analog meter. Because main loops around evey 20 ms the average is calculated slowly and the analog meter also reacts slow. Notice that this delay does not impact the speed of detecting particles as that is done in an interrupt that will run regardless of what the main program is doing.

while (1) 
    {    
        if (one_second)
        {
            one_second = 0;                              //clear message from interrupt
            
            logarithm_of_cps = log(counts_per_second);   //take logarithm of counts recorded in 1 second
            counts_per_second = 1;                       //then clear that number (NOT to ZERO!)
        }
        
        
        average = (average * 127 + logarithm_of_cps) / 128;   //average it with previous measurements
        if (average < 6.0)                                //less than 400 cps
        {
            OCR0B = (int) (average * 40);                 //set PWM value for analog meter
            OCR0A = 255 - OCR0B;                          //my analog meter has its zero in the middle
        }
        else                                              //of the scale, so with no CPS it has to 
        {
            OCR0B = 255;                                  //be pulled low (negative current)
            OCR0A = 0;
        }
        _delay_ms(20);                                    //slow down the process, for a smooth meter reaction
    }

The analog meter was so big that I had to make a hole in the perfboard. For the GM tube a small hole was made in the plastic project box so that the "dangerous" high voltage side was safe in the inside but most of the tube stuck out of it. You can also see a (part of) a big screw where the "headphones-jack" with the Americum-241 is mounted.

Wikipedia tells me that:

Americium-241 (241Am, Am-241) is an isotope of americium. Like all isotopes of americium, it is radioactive, with a half-life of 432.2 years.

So although the amount of it is extremely small 0.33 microgram ! It will last a long time. In the video you can see that it produces quite a lot of particles, the flashes of the red led (and if you can hear it, clicks of the speaker)

I replaced the original scale of the analog meter (-80uA...+80uA) with a logarithmic scale drawn on paper and glued it to the back of the original scale. It is "somewhat" accurate...