COMPTEUR GEIGER SUR UN ROVER

COMPTEUR GEIGER
 SUR UN ROVER
Thomas LAISNEY, Daphné ROUSSEAU, Maxence PIAT

Résumé
Dans le cadre du module d’instrumentation et mesures physiques pour la
troisième année de Licence de Sciences de la Terre, un rover avec un compteur
geiger a été créé. Les différentes étapes seront listées et détaillées dans cet
article pour au final répondre à la problématique qui a mené au développement
de ce rover. La science, source constante d’évolution et de nouvelles
technologies, n’est autre que le meilleur outil pour aider à améliorer la qualité
de vie. Un rover Geiger permettant de déterminer à distance les émissions
radioactives d’un endroit donné était l’objectif de ce projet. Entre l’idée
naissante du projet et l’aboutissement complet de l’objet, cela à été un long
chemin parsemé de défis à relever. Dans cet article les différentes étapes du
développement complet du rover Geiger seront expliquées, avec le types de
pièces et codes utilisés, les difficultés rencontrées, le tout illustré par des
photographies. La formation réussie de ce rover a même permis d’effectuer des
mesures de radioactivité dans l’enceinte de l’OSUC pour tester sa fiabilité et le
projet est une réussite.

1 INTRODUCTION
La problématique nécessitant la fabrication de ce rover est la suivante :
Pouvoir mesurer le taux de radioactivité à distance. La fabrication d’un
rover équipé d’un compteur Geiger était la meilleure option.

2 MONTAGE
Les composants utilisés sont les suivants :

    -   un rover Cherokey 4WD

    -   une carte arduino uno modifié appelé Roméo BLE

2

-   une carte arduino UNO qui va récupérer les données

    -   un compteur geiger Arduino

    -   un adaptateur à carte SD arduino

3

La carte Romeo va recevoir le code permettant de faire bouger les roues
du Rover et ne seront reliées qu’à celles-ci. Cette carte étant compatible
bluetooth, nous utiliserons l’application android Bluno Remote afin de
contrôler le Rover. Ensuite, les données sont mesurées à l’aide du
compteur geiger arduino, celui-ci est connecté à une carte arduino UNO
qui va récupérer le nombre de “coups” ou de désintégrations par minutes
et enfin envoyer ces données dans une carte micro sd par le biais d’un
adaptateur arduino. (photos annexe B)

3 LE PROGRAMME EN C POUR L’ARDUINO
Premièrement, le code (annexe B) pour contrôler le Rover a été récupéré
sur le site des fabricants de la carte (et du rover) et aucunes librairies
n’ont été importées. Les changements effectués sur celui-ci ont été au
niveau des touches pour les différentes directions :

      Avant                                            Après

4

En effet, les lettres pour les différentes directions sur l’application ne
peuvent être changées, elles ont donc été modifiées sur le code en accord
avec l’application

Pour ce qui est de la partie données (code en annexe C), un code pour le
compteur geiger nous a été donné sur lequel nous avons greffé le code
“ReadWrite” dans la partie “SD” des exemples de code du logiciel arduino.
Les librairies “SPI.h” et “SD.h” ont été récupérées dans le logiciel pour SD.h
et téléchargées depuis l’option “gérer les bibliothèques” sous le nom de
“RadiationWatch” pour SPI.h

Le code pour les données de radioactivités permet d’enregistrer chaque
désintégration ou “coups” et se réinitialiser au bout d’une minute. Cette
donnée au bout d’une minute est alors enregistrée dans la carte SD.

4 DISCUSSION SUR LES PROBLEMES TECHNIQUES
Plusieurs problèmes se sont manifestés au cours de toutes les étapes dans
la construction du projet.

La première question que nous nous sommes posés était de savoir la
façon dont on allait piloter le rover. Très vite et après quelques recherches
la solution du Bluetooth paraissant la plus simple du fait que le Rover est
équipé du fonction Bluetooth. Le code en lui-même n’a pas posé beaucoup
de soucis, en revanche trouver une bonne application qui permettait à la

5

fois de se connecter au rover et de le piloter a été plutôt compliqué.
Beaucoup d’applications permettaient de se connecter au rover mais les
touches ne fonctionnaient pas. L’application envoyait bien les données, le
rover recevait les informations mais l’application ne recevait rien en
retour et le rover restait immobile. Heureusement certaines permettaient
de modifier les touches associées aux mouvements et les mettre en
adéquation avec les touches du code. Malgré tout, même si les applications
se sont révélées assez pratiques, il est arrivé que certaines ne
fonctionnaient plus d’une semaine à l’autre, et ce sans que le code ait été
modifié entre temps, et sans aucune raison apparente. Une seule
application sur un seul de nos portables est restée fiable, c’est donc celle là
que nous avons utilisé par la suite.

Lors de nos premiers essais, le rover ne fonctionnait que lorsqu’il était
relié à l’ordinateur, pour cela, une simple batterie externe a suffi à mettre
en autonomie le rover une fois débranché du PC.

Lors de notre premier essai, le rover avançait à une vitesse relativement
élevée (compte tenu de la taille et de la batterie qui l'alimente), mais lors
de notre deuxième essai, la vitesse a alors nettement diminué, bien que la
vitesse indiquée dans le code soit réglée sur son maximum possible. Après
l’avoir branché sur une batterie de plus grosse capacité et après avoir
enlevé du poids sur le rover, cela n’a rien changé et nous n’avons pas
trouvé de solution à ce problème.

Nous avons aussi rencontré des problèmes liés à l’Arduino. L’Arduino
intégré dans le rover était connecté aux roues mais ne pouvait se brancher
à la fois sur les moteurs et faire fonctionner le compteur Geiger en même
temps. Nous avons donc dû monter un deuxième Arduino sur le rover afin
que tout tienne en même temps. Problèmes donc résolu.

Une fois tout monté, il restait des soucis liés au stockage de nos données.
Lorsque l’on activait le compteur Geiger, la réception des données se
faisait bien mais pas la conservation, elles s’effaçaient instantanément.
Nous avons donc dû brancher un adaptateur pour placer une carte Micro
SD. La Micro SD a elle aussi eu des problèmes par rapport à la
conservation des données une fois le compteur Geiger mis en route. Le

6

problème était lié à une erreur dans le code initial de la carte SD. Le
problème a donc été réglé et les données sont maintenant reçues et
stockées.

5 RESULTATS
Une fois que tous les problèmes ont été résolus, nous avons pu
commencer à tester les différents endroits autour et à l’intérieur de l’Osuc,
mais aussi à Olivet. Les résultats ont été récupérés et voici ce qu’ils
donnent :

Ci-dessus, voici des résultats que l’on peut qualifier de taux “faibles” car
les données sont assez basses. On remarque ici que les résultats sont
donnés en nombre de désintégration par minute, c'est-à-dire en cpm. Les
résultats montrent que pour la zone intérieur (salle de classe au rez-de-
chaussée), on obtient entre 20 cpm et 71 cpm. D’autres zones montrent
des résultats similaires à ceux obtenus dans la zone intérieure. Ces deux
zones sont la machine à café et l’entrée de l’Osuc (intérieur). On peut voir
que les résultats présentent eux aussi des taux faibles de cpm, allant de 17
cpm à 33 cpm. On notera par ailleurs que ces deux dernières zones
présentent des taux de désintégration plus faibles que la zone Intérieure.

7

les zones présentent de faibles radiations, ce qui est rassurant, les salles
de cours sont saines !

La zone présente au niveau de l’entrée de l’Osuc montre une radiation
bien plus importante que les zones vues précédemment, entre 87 cpm et
308 cpm.

En avançant sur le parking, on remarque la présence de granite, les
granites sont connus pour être légèrement radioactifs.

On observe ici que le nombre de cpm est bien plus élevé que tous les
autres endroits. Les données se rapprochent de l’entrée extérieur de
l’Osuc (cette zone présente peut être elle aussi des granites au alentours
que nous n’avons pas vu). Les résultats montrent des radiations allant de
139 cpm à 555 cpm. Ces taux sont plus élevés que le reste mais ne sont
pas dangereux pour autant. Nous avons toutefois trouvé des résultats
extrêmement élevés par rapport au reste, allant jusqu'à 2000/3000 cpm.
Ils ont été captés dans une zone d’Olivet(Jardin), dans la forêt à côté du
parking (Pinède) et derrière l’Osuc (présence de granite). Il s’est avéré
que l’action des photons engendrait des données trop élevées et un simple
carton sur le rover a permis de résoudre le problème.

8

Malgré quelques données corrompues, le rover a permis de capter des
informations conformes aux attentes. Les zones présentant des roches
légèrement radioactives ont donné des taux de désintégration par minute
plus élevés que les zones intérieures de l’Osuc comme les salles de cours
ou la machine à café.

6 CONCLUSIONS ET PERSPECTIVES
L’élaboration de ce projet a permis de se rendre compte que ce n’était pas
si facile. Néanmoins, les erreurs de codages, de branchages ainsi que les
erreurs d’applications de téléphone et tous les autres petits soucis
rencontrés nous ont permis d’en apprendre plus et d’évoluer ainsi que de
devenir nettement plus efficaces au fil des semaines. Les applications
téléphone nous ont beaucoup ralenties car, comme précisé au dessus,
nous avons passé beaucoup de temps à programmer comme il faut les
applications, à connecter nos téléphones au rover. Toutefois, ces
applications nous ont permis d’en apprendre plus sur le fonctionnement
du rover et sur les lignes de code qui correspondaient aux échanges de
données par exemple. Également, ces applications nous ont été vraiment
utiles et c’est important de le souligner.

9

De plus, nos faibles connaissances en matière de codage ont été un léger
frein à l’élaboration du projet. L’autre point qui aura sûrement été une
déception plus qu’autre chose, ainsi qu’une question auquelle nous
n’avons toujours pas la réponse, est la vitesse du rover. Si jamais nous
devions nous repencher sur ce projet pour y apporter des améliorations il
faudrait absolument régler ce soucis. Mais pour finir sur une note plus
positive, il faut souligner que nous avons réussi à venir à bout de ce projet
dans les temps et que c’est une réussite.

Pourquoi pas ensuite réutiliser ce type de rover pour y mettre d’autres
types de capteurs pour recueillir des données dans le cadre de projets
géologiques par exemple. L’avantage de ce type de rover c’est
l’adaptabilité, la taille et la possibilité d’y mettre ce qu’on veut dessus, il
est donc facile de l’adapter à toutes les situations, et pas que dans la
géologie!

7 ANNEXE
   A. Montage du Rover

10

B. Code pour le mouvement du Rover :

//Standard PWM DC control
int E1 = 5; //M1 Speed Control
int E2 = 6; //M2 Speed Control
int M1 = 4; //M1 Direction Control
int M2 = 7; //M1 Direction Control

///For previous Romeo, please use these pins.
//int E1 = 6; //M1 Speed Control
//int E2 = 9; //M2 Speed Control
//int M1 = 7; //M1 Direction Control
//int M2 = 8; //M1 Direction Control

#define PERIOD 60000.0 // (60 sec) one minute measure period

11

volatile unsigned long CNT; // variable for counting interrupts from
dosimeter
unsigned long dispPeriod; // variable for measuring time
unsigned long CPM; // variable for measuring CPM

void stop(void) //Stop

{
    digitalWrite(E1,LOW);
    digitalWrite(E2,LOW);
}
void advance(char a,char b)   //Move forward
{
  analogWrite (E1,a); //PWM Speed Control
  digitalWrite(M1,HIGH);
  analogWrite (E2,b);
  digitalWrite(M2,HIGH);
}
void back_off (char a,char b) //Move backward
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);
  analogWrite (E2,b);
  digitalWrite(M2,LOW);
}
void turn_L (char a,char b)   //Turn Left
{
  analogWrite (E1,a);
  digitalWrite(M1,LOW);
  analogWrite (E2,b);
  digitalWrite(M2,HIGH);
}
void turn_R (char a,char b)   //Turn Right
{
  analogWrite (E1,a);
  digitalWrite(M1,HIGH);
  analogWrite (E2,b);
  digitalWrite(M2,LOW);
}
void setup(void)
{

CNT = 0;
CPM = 0;
dispPeriod = 0;

12

attachInterrupt(1,GetEvent,FALLING); // Event on pin 2

 int i;
 for(i=4;i=dispPeriod + PERIOD) { // If one minute is over
CPM = CNT;
CNT = 0;
dispPeriod = millis();
}

  char val = Serial.read();
  if(val != -1)
  {
    switch(val)
    {
    case 'U'://Move Forward
      advance (255,255); //move forward in max speed
      break;
    case 'D'://Move Backward
      back_off (255,255); //move back in max speed
      break;
    case 'L'://Turn Left
      turn_L (100,100);
      break;
    case 'R'://Turn Right
      turn_R (100,100);
      break;
    case 'z':
      Serial.println("Hello");
      break;
    case 'C':
      stop();
      break;
    }
  }

13

// else stop();
}

void GetEvent(){ // Get Event from Device
CNT++;
}

     C. Code pour le compteur geiger et l’enregistrement sur la carte
        SD

#define PERIOD 60000.0 // (60 sec) one minute measure period
volatile unsigned long CNT; // variable for counting interrupts from
dosimeter
unsigned long dispPeriod; // variable for measuring time
unsigned long CPM; // variable for measuring CPM

/*
 SD card read/write

  This example shows how to read and write data to and from an SD card
file
  The circuit:
  SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)

 created Nov 2010
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe

 This example code is in the public domain.

*/

#include 
#include 

File myFile;

14

void setup() { // setup
Serial.begin(9600);

CNT = 0;
CPM = 0;
dispPeriod = 0;
attachInterrupt(0,GetEvent,FALLING); // Event on pin 2
// Open serial communications and wait for port to open:
 Serial.begin(9600);
 while (!Serial) {
   ; // wait for serial port to connect. Needed for native USB port only
 }

 Serial.print("Initializing SD card...");

 if (!SD.begin(4)) {
   Serial.println("initialization failed!");
   while (1);
 }
 Serial.println("initialization done.");
 myFile = SD.open("test.txt", FILE_WRITE);

 // if the file opened okay, write to it:
 if (myFile) {
   Serial.print("Writing to test.txt...");
   myFile.println("testing 1, 2, 3.");
   // close the file:
   myFile.close();
   Serial.println("done.");
 } else {
   // if the file didn't open, print an error:
   Serial.println("error opening test.txt");
 }

}
void loop() {

//Serial.print("CPM:");
Serial.println(CNT);

if (millis() >=dispPeriod + PERIOD) { // If one minute is over

CPM = CNT;

15

CNT = 0;
dispPeriod = millis();

myFile = SD.open("test.txt", FILE_WRITE);
myFile.println(CPM);
myFile.close();
}
}

void GetEvent(){ // Get Event from Device
CNT++;
}

16