Wie vor längerer Zeit im Blog angekündigt, soll der Geigerzähler nun eine Software bekommen, die nicht nur die Pulse des Zählrohres zählt, sondern sie auch auf eine Einheit bezieht. Hierzu waren aber noch kleine Änderungen an der Hardware notwendig. (genauer gesagt habe ich andere Pins des Arduino verwendet – was bedeutet: Leiterbahnen durchtrennen und mit Schaltlitzen neu verlegen). Hier eine Liste der Änderungen:

• die Leitung von Pin4 Arduino zu Pin D7 vom LCD unterbrechen
• die Leitung von Pin5 Arduino zu Pin D6 vom LCD unterbrechen
• D7 vom LCD an Pin12 vom Arduino verbinden
• D6 vom LCD an Pin13 vom Arduino verbinden
• der Zählimpuls wird von TP3 auf Arduino Pin4 geschaltet
• die Verbindung TP3 zu Arduino Pin23 wird getrennt

Daraus ergibt sich folgende I/O Port/Pin Belegung:

LCD Display:

RS – Ardunio PIN18 – Arduino  I12
EN – Arduino PIN17 – Arduino  I11
D4 – Arduino PIN11 – Arduino  I5
D5 – Arduino PIN6  – Arduino  I4
D6 – Arduino PIN13 – Arduino I7
D7 – Arduino PIN12 – Arduino  I6

Weitere Pins:

COUNT – Arduino PIN4 – Arduino I2
BUZZ – Arduino PIN14 – Arduino I9
STATUS – Arduino PIN3 – Arduino I1
SET – Arduino PIN2 – Arduino I1

Hier der Arduino Code:

/*Geiger Vx.1 geändertes pinning
* Pinzuordnungen allgemein für LCD
* RS to IO12 (pin18)
* EN to IO11 (pin17)
* D4 to IO5  (pin11)
* D5 to IO4  (pin6)
* D6 to IO7  (pin13)
* D7 to IO6  (pin12)
* R/W to ground
* VSS to ground
* Pinzuordnungen für Counter
* count to IO2 (ic pin4) = INT0
* buzzer to IO9 (ic pin15)
*/

// include libraries
#include <LiquidCrystal.h>

// interfacepins initialisieren
LiquidCrystal lcd(12,11,5,4,7,6);

// Dosiskobersionsfaktor - CPM to uSV/h
#define dconv 0.007  //(ca Umrechnung aus Diagramm Datenblatt des ZP1400 Zählrohrs)

// Konstanten Hardware I/Os
const int buzzerpin = 9;
const int geiger_input = 2;
const int keystat = 0;
const int keyset = 1;

// Variablen
long count = 0;
long countPerMinute = 0;
long timePrevious = 0;
long timePreviousMeassure = 0;
long time = 0;
long countPrevious = 0;
float radiationValue = 0.0;

void setup(){
pinMode(geiger_input, INPUT);
Serial.begin(19200);

//setup LCD und Begruessungsanzeige
lcd.begin(8, 2);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" Geiger ");
lcd.setCursor(0,1);
lcd.print("Counter ");
delay(1000);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print("V0.0 beta");
delay(1000);

lcd.clear();
lcd.setCursor(0,1);
lcd.print("ibiretro");
delay(500);
for (int i=0;i<8;i++){
delay(200);
tone(buzzerpin,i*100,100);
lcd.scrollDisplayLeft();
}

delay(500);

lcd.clear();
lcd.setCursor(0, 0);
lcd.print("CPM=");
lcd.setCursor(4,0);
lcd.print(6*count);
lcd.setCursor(0,1);
lcd.print(radiationValue);

attachInterrupt(0,countPulse,RISING);

}

void loop(){
if (millis()-timePreviousMeassure > 10000){
countPerMinute = 6*count;
radiationValue = countPerMinute*dkonv;
timePreviousMeassure = millis();

lcd.clear();
lcd.setCursor(0, 0);
lcd.print("CPM=");
lcd.setCursor(4,0);
lcd.print(countPerMinute);
lcd.setCursor(0,1);
lcd.print(radiationValue,4);
lcd.setCursor(6,1);
lcd.print(" uSv/h");
/* zum debuggen 
Serial.print("cpm=");Serial.print(countPerMinute,DEC);
Serial.print("uSph=");Serial.println(radiationValue,4);
*/
count = 0;

}

}

void countPulse(){
detachInterrupt(0);
count++;
tone(buzzerpin,1000,10);
while(digitalRead(2)==1){
}
attachInterrupt(0,countPulse,RISING);
}

Das Thema „Radioaktive Strahlung“ bzw. deren Messung, beschäftigt mich auch immer wieder. In einem alten Weblogeintrag habe ich bereits einmal einen Geigerzähler geplant und ihn als Ausbildungsprojekt mit dem damaligen Elektroniker-Lehrling gebaut. Als Zählrohr kam ein Philips-Rohr ZP1400 aus meinen alten Lagerbeständen zum Einsatz. Die benötigte Betriebsspannung für das Zählrohr generierte ein, über einen 555er angesteuerter Transformator/Wandler mit nachgeschalteter Greinacherkaskade. Diese Schaltung hat den Nachteil, dass sie relativ viele und große Komponenten benötigt und somit auch einen unhandlichen Aufbau nach sich zieht.  Die Schaltung hat die Impulse lediglich auch nur hörbar gemacht. Einen Zähler, oder Integrator hat die Schaltung nicht mehr bekommen. -> man konnte ja optional ein Mikrocontroller Board (Arduino UNO , PIC, etc.) anschliessen…

Auf jeden Fall wollte ich noch einen anderen Detektor bauen. Irgendwann habe ich bei Neuhold-Elektronik günstig ein weiteres Zählrohr gefunden und auch gleich bestellt. Dabei handelt es sich um eine Geiger-Müller Röhre RFT VA-Z-114 (70014NR) aus DDR Beständen. Also warum damit nicht noch einen weiteren Geiger-Müller Zähler basteln. Diesmal sollte die Elektronik jedoch um einiges kleiner ausfallen. Als Grundlage für den neuen Zähler diente das Konzept eines Bausatzes von Pollin, der schon lange nicht mehr lieferbar ist, jedoch noch immer auf der Webseite publiziert wird. Teile dieses Schaltungskonzeptes habe ich nun für dieses Projekt herangezogen. Hier wird die Hochspannung mit einem Boostconverter – IC MC34063 der über einen FET eine 330uH Induktivität schaltet, erzeugt. Die Impulse der Röhre werden über Schmitt-Trigger und Filter aufbereitet und die Software in einem ATTINY2313 übernimmt das Zählen.

Die Spannungserzeugung habe ich hier übernommen. Für die Auswertung kommt jedoch der Atmega328 zum Einsatz. Ein kleines LC-Display (mit 8×2 Zeichen) wird die Impulse anzeigen. Ein paar andere Funktionen, wie Batteriespannung etc. sollen auch noch implementiert werden, da der Atmega ja auch A/D- Converter Eingänge hat und mit 10Bit auch eine genügend hohe Auflösung. Die ganze Schaltung sollte dann so groß werden, dass sie in einem 15x8x5cm großen Gehäuse Platz findet. Als Energiequelle wird eine 9V Blockbatterie zum Einsatz kommen.

Der Schaltplan ist schnell gezeichnet und daraus ein Layout erstellt.

Das ist das Platinenlayout in der ersten Version. Eine einseitig gelayoutete Platine mit ausschließlich bedrahteten Bauteilen wird hier völlig ausreichend sein und kann die geplante Größe einfach erreichen. Nach den folgenden drei Fertigungsschritten: (auch hier zu sehen)

Bohrplotten

Belichten und Entwickeln

und abschließend Ätzen,

ist die Platine soweit fertig, dass sie bestückt werden kann. Vorher wird auf die Kupferseite noch eine Schicht Lötlack aufgetragen, um hässliche Korrosionen der Kupferschicht zu vermeiden und eine gute Lötoberfläche zu erhalten.

Das ist die Platine in der bestückten Ausführung. Hier fehlen noch der Mikrocontroller, das LC-Display und natürlich das Zählrohr. Doch zuerst habe ich begonnen, das Gehäuse vorzubereiten und eine Alu-Frontplatte zu erstellen, die dem ganzen Konstrukt ein etwas schöneres Aussehen verleiht. Ein Layout hierfür kann mit allen möglichen Konstruktionstools erstellt werden, die die Möglichkeit bieten, die Zeichnung beispielsweise im „dxf“-Format zu exportieren. Die vhf-Fräsbohrplotter müssen jedenfalls mit den Exportformaten umgehen können und sie idealerweise auch maßstabsgetreu auf den Rohling übertragen können.

Das Ergebnis der Fräsarbeiten, sind diese beiden Platten, die dann miteinander verschraubt werden, das Display, die Schalter und Taster halten sollen. Damit die eingefrästen Vertiefungen in der Aluminiumplatte schlussendlich auch schön kontrastreich zu sehen sind, werden sie mit schwarzem Acryllack gefüllt.

So sieht die fertige Frontplatte aus.

Jetzt wird die Elektronik im Gehäuse untergebracht. Wie hier gut zu erkennen ist, hat wieder das ZP1400 Zählrohr von Philips seinen Platz gefunden. Leider war dem Neuhold – DDR Zählrohr trotz vieler Experimente kein einziger Impuls zu entlocken. Ich vermute, das Rohr hat im Laufe der vielen Lagerjahre Luft gezogen und ist einfach defekt.

Alle Komponenten haben ihren Platz gefunden. Die „Trennkammern“ sind kupferbeschichtete FR4 Platten, die einerseits die Röhre in Position halten und andererseits eine Kammer für die 9 Volt Blockbatterie darstellen.

Hier ist nun alles zusammengebaut. Als Testsoftware werden die Impulse vorerst lediglich nur über einen IRQ Eingang gezählt und über den kleinen Lautsprecher hörbar gemacht. Wenn das Programm dann einmal fertig ist, werde ich es hier wieder veröffentlichen…