La physique COMPUTATIONNELLE au lycée

La mallette COSMIX est un détecteur de particules dédié à la mise en évidence et au comptage des rayons cosmiques. Elle est construite autour de deux détecteurs de particules chargées constitués chacun d'un barreau d'iodure de césium instrumenté d'une photodiode et relié à une chaîne d'acquisition pilotée par une carte Arduino.

Le capteur

L'élément principal du capteur est constitué d'un barreau d'iodure de césium, ce sel est un matériau scintillant inorganique (il existe des scintillateurs plastiques dits « organiques »), c'est-à-dire un matériau qui a la propriété de produire un rayonnement dans le visible lorsqu'il est traversé par une particule chargée. Le barreau est translucide et entouré de matériau réfléchissant, la lumière produite par une particule chargée est donc guidée vers l'extrémité du cristal qui est équipé d'une photodiode. Une particule chargée traversant le barreau dépose donc de l'énergie qui est convertie par le cristal en signal lumineux visible qui vient éclairer la photodiode qui à son tour produit un signal électrique.

Les cristaux des mallettes COSMIX sont des éléments de récupération. À l'origine du projet, l'équipe du CENBG disposait de 48 cristaux issus des tests sous faisceau des éléments du calorimètre du détecteur LAT embarqué à bord du satellite d'astronomie des rayons γ Fermi. Les tests effectués auprès des grands accélérateurs de particules européens (CERN, GSI, GANIL) étant terminés, les cristaux d'iodure de césium ont été remisés dans une armoire. L'idée a donc été de mettre ces véritables détecteurs de physique des particules à la disposition du grand public. Chacun des 48 barreaux a été scié en deux demi-barreaux qui constituent les deux détecteurs de la mallette COSMIX.

La chaîne de conditionnement du signal

Le signal électrique issu de la photodiode est extrêmement faible, il subit alors une première préamplification au niveau de l'électronique présente dans le capot à l'arrière du détecteur. Ce signal préamplifié (figure 1) rejoint alors une chaîne d'amplification et de mise en forme (figure 2) des signaux présente dans le boîtier gris à l'avant de la platine supportant les différents éléments du détecteur. Enfin, pour chacun des deux détecteurs le signal amplifié est traité par un discriminateur qui génère un signal numérique TTL (état haut à 5 V) (figure 2). La coïncidence des deux signaux produit un troisième signal TTL indiquant que la particule cosmique a traversé les deux barreaux.

Acquisition de données - La carte Arduino

Les trois signaux TTL sont alors traités par une carte Arduino MEGA, les signaux numériques issus de chacun des détecteurs sont utilisés pour déclencher une interruption dont le rôle est d'incrémenter les compteurs. À chaque interruption, le signal TTL de coïncidence est testé en lisant son état sur une voie numérique de la carte Arduino.

Autour de la carte Arduino - Interfaçage et sous-systèmes

Le microcontrôleur embarqué sur la carte Arduino offre des possibilités qui vont bien au-delà de la simple capacité à compter des évènements. Dans le cadre de COSMIX, la carte Arduino va être chargée de gérer l'ensemble des fonctionnalités offertes par la mallette, de la gestion de l'interface homme-machine au pilotage des séquences d'acquisition et la sauvegarde des données en passant par l'acquisition de données complémentaires en provenance d'autres sous-systèmes physiques apportant des informations complémentaires à l'acquisition de chaque évènement.

Acquisition et sauvegarde des données

La carte Arduino est utilisée pour gérer les différentes prises de données, démarrage des comptages, arrêt des comptages, réinitialisation des compteurs software et sauvegarde des données de chaque évènement sur la carte SD.

Interfaçage

La carte Arduino permet aussi la gestion des affichages sur l'écran LCD, elle gère les différents menus ainsi que l'interaction avec les boutons du panneau de commande. Elle pilote aussi les échanges sur le port série (USB) permettant ainsi d'envoyer des informations à l'ordinateur connecté et à en recevoir les instructions sur le paramétrage de l'acquisition de donnée. Un « mini » protocole est défini, qui permet de transmettre à distance l'ensemble des instructions qui sont par ailleurs accessibles par le système de menu associé aux boutons du panneau de commande. Plus anecdotiquement, la carte gère aussi un système de signaux sonores permettant d'identifier quel détecteur a été touché et s'il y a eu coïncidence ou non.

Sous-systèmes

La même carte Arduino permet aussi l'acquisition sur les différents sous-systèmes connectés à la carte. Outre les systèmes d'interfaçage avec l'utilisateur et de sauvegarde des données qui ont déjà été abordés dans les sections précédentes, des modules prise de données auxiliaires sont aussi pilotés par la carte. Ainsi à chaque particule détectée, l'évènement généré contient aussi l'information de la température, de la pression (calcul de l'altitude), du temps d'arrivée (horloge RTC), et de la position GPS du détecteur.

Le code pilotant l'ensemble des fonctionnalités de la mallette occupe un espace mémoire légèrement supérieur à la capacité d'une classique carte Arduino UNO, c'est pour cette raison qu'il lui a été préféré une MEGA aux capacités sensiblement supérieures pour ce qui concerne le stockage.

Acquérir des données avec Arduino

Même si le code de pilotage des mallettes COSMIX peut paraître impressionnant (il ne fait, malgré tout que 1520 lignes), finalement le pilotage de chacune des fonctionnalités élémentaires ne demande la mise en œuvre que de quelques fonctions, le programme complet étant pour l'essentiel construit par l'agglomération des morceaux de code relatifs à chacun des sous-systèmes, les seuls points critiques résidant éventuellement dans leur coordination.

Nous allons démarrer avec l'équivalent du fameux Hello world qui est traditionnellement le premier programme que l'on écrit quand on démarre la programmation. Avec Arduino, il s'agit de faire clignoter la DEL jaune de test (ou rouge suivant modèle). Cela permet de vérifier le bon fonctionnement et de découvrir l'environnement Arduino : liaison USB carte - PC, l'environnement de programmation encore appelé IDE ainsi que la structure d'un programme Arduino, sans faire aucun montage. Pour ce faire, il suffit d'ouvrir le programme (ou sketch) Blink dans le menu : Fichier → Exemples → Basics → Blink.

Il se peut que le code contenu dans le fichier ne soit pas tout à fait le même, aucune importance pour le test de mise en route.

Remarque : dans la communauté Arduino, les programmes sont appelés sketch en anglais, ce qui fréquemment traduit par croquis et que l'on peut nommer programme.

Une fois le programme chargé si vous pouvez observer la DEL jaune (ou orange) clignoter c'est que votre installation est réussie. Dans le cas contraire, revoir la procédure d'installation.

Elle doit contenir :

• une fonction setup exécutée une seule fois au lancement du programme :

  • concept de fonction : une fonction est un bloc permettant d'organiser et d'éviter les répétitions de code. Elle joue un rôle important pour la modularité du code. Une fonction possède un type (void, int, float, String…), un nom, d'éventuels paramètres entre parenthèses et un ensemble d'instructions définies dans un bloc délimité par des accolades {…},
  • exemple : pour faire clignoter la LED test, il a été nécessaire de déclarer et d'initialiser la broche numéro 13 comme une sortie numérique à l'aide de la fonction : pinMode(13, OUTPUT). La fonction pinMode accepte deux paramètres, le numéro de la broche et le mode (INPUT ou OUTPUT). Il existe un troisième mode INPUT_PULLUP dont je ne parlerais pas. Les valeurs passées à l'appel de la fonction sont appelées arguments et valent respectivement 13 et OUTPUT. Vous l'avez compris INPUT = entrée et OUTPUT = sortie ;

• une fonction loop dont toutes les instructions sont exécutées en boucle tant que le programme s'exécute. C'est grâce à cette fonction que l'on peut faire clignoter la DEL de notre programme test. Toutes les instructions associées à la fonction loop sont regroupées dans un bloc délimité par des accolades : { }

  • concept d'instruction : on appelle instruction une ligne de programme qui effectue une action,
  • exemple : digitalWrite(led, HIGH); et delay(1000); sont des instructions au même titre que déclarer une variable, afficher un message à l'écran, ouvrir la liaison série ;

• des variables globales permettant de déclarer les différentes broches utilisées. Elles sont déclarées en dehors de tout bloc, généralement en en-tête du programme et peuvent être utilisées dans toutes les fonctions du programme contrairement aux variables locales déclarées dans un bloc (fonction, if, for…) et utilisables uniquement dans ce bloc.

  • concept de variable : une variable désigne une case (ou un ensemble de cases) de la mémoire de l'ordinateur pour stocker de l'information. Lors de la déclaration d'une variable, il est impératif d'indiquer le type de cette variable et le nom de variable. Le type permet de déterminer si la variable est un entier (int), un flottant (float) ou bien une chaîne de caractères (String). Il existe beaucoup d'autres types que nous n'aborderons pas dans cette initiation,
  • exemple : int led = 13; est une instruction qui permet de déclarer la variable globale dont le nom est led de type entier et de l'initialiser avec la valeur 13.

Quelques exemples d'utilisation des fonctions : setup et loop

void setup() {
    Serial.begin(9600);
    Serial.print("Coucou ");
}
void loop() {
    //vide rien à répéter
}

void setup() {
    Serial.begin(9600);
}
void loop() {
    Serial.print("Coucou ");
    delay(1000);
}

1. Pour chaque exemple (à tester l'un après l'autre) téléverser, c'est-à-dire télécharger dans la mémoire de la carte Arduino, le programme et ouvrir le moniteur série (Outils → Moniteur série ou bien l'icône de la loupe en haut à droite) et en déduire l'intérêt de la fonction loop.

À chaque lancement du moniteur série, le programme Arduino redémarre, c'est-à-dire qu'il est lu dans son intégralité, la fonction setup est de nouveau exécutée. L'instruction : Serial.begin(9600); démarre une communication série à la vitesse de 9600 bauds. Il faut donc que le moniteur série soit configuré sur ce débit… sinon vous verriez des caractères bizarres apparaître à l'écran. En pratique, on utilise une valeur comprise entre 9600 et 115 200. Plus le débit est élevé et plus la communication est rapide.

int i ;
void setup() {
    Serial.begin(9600);
    i =0;
}
void loop() {
    String s = " mot";
    Serial.print(s);
    Serial.print(i);
    i = i + 1;
    delay(1000);
}

void setup() {
    Serial.begin(9600);
    int i =0;
}
void loop() {
    Serial.print("\t");
    Serial.print("mot");
    Serial.print(i);
    i = i + 1;
    delay(1000);
}

2. Taper l'exemple 3, téléverser le programme et ouvrir le moniteur série. Comment est affiché le contenu des variables i et s ?

3. Combien de variables sont présentes dans l'exemple 3 ? Combien y a-t-il de variables globales ?

4. Dans l'exemple 4, on obtient le message d'erreur suivant :

sketch_aug01a.ino: In function ‘void loop()':
sketch_aug01a.ino:10:16: error: ‘i' was not declared in this scope

Quelle erreur a-t-on commise ? Modifier le programme pour qu'il n'indique plus d'erreur.

5. Quelle modification apporte l'instruction : Serial.print("\t"); ?
Instruction très utile dans la suite de ce document.

En complément de la structure minimale

• On se doit d'ajouter des commentaires pour une meilleure lecture des fonctionnalités du programme. Une ligne de commentaires démarre avec deux antislashs (antislash = barre oblique inversée). Il est également possible d'ajouter plusieurs lignes de commentaires en les encadrant pour commencer par une barre oblique suivie d'une étoile et pour finir d'une étoile suivie d'une barre oblique : /* Vos commentaires */
  Pour des exemples d'utilisation, relire le programme permettant de faire clignoter la LED de test.
• On peut également ajouter des fonctions autres que setup et loop. Ce que nous ne ferons pas lors de cette formation.

Les entrées / sorties numériques

Sur le schéma de présentation de la carte Arduino, nous avons vu qu'il y avait 14 entrées / sorties numériques et 6 entrées analogiques. Il n'y a donc pas de sorties analogiques. Pour les sorties, nous utiliserons la commande digitalWrite(broche, état), qui est donc une commande d'écriture. Pour les entrées, nous utiliserons la commande digitalRead(broche), qui, vous l'aurez peut-être deviné, est une commande de lecture. Une broche est donc considérée comme une entrée ou une sortie, mais pas les deux. Il est donc important de bien définir si la broche va se comporter comme une entrée ou une sortie. C'est ce que nous avons fait dans l'exemple de départ Blink grâce à la commande : pinMode(broche, mode).

• mode OUTPUT : pour indiquer à la carte que la broche doit être en mode écriture, c'est-à-dire qu'elle peut envoyer ou non du courant. C'est donc une sortie.
• mode INPUT : pour indiquer que la broche est en mode lecture. Elle ne va donc pas piloter du courant, mais être à l'écoute du courant qui lui arrive.

Pour faire clignoter la LED test, nous avons utilisé la commande pinMode(led, OUTPUT) pour indiquer à la broche 13 de fonctionner en mode écriture et nous avons modifié l'état (broche numéro 13) à l'aide de la fonction digitalWrite qui accepte deux paramètres, le numéro d'entrée/sortie de la broche et l'état HAUT ou BAS de cette broche.

Les entrées analogiques :

Pour lire les valeurs en sortie d'un capteur branché sur une entrée analogique, on utilise la fonction analogRead qui accepte un seul paramètre, le numéro de broche. Le programme minimum est :

// On utilise la broche numéro A0
// const spécifie que la variable n'est pas modifiable.
const int broche_capteur = A0;

void setup() {
    // Votre code
}

void loop() {
    // valeur numérique lue sur la broche A0
    // avec une variable qui n'a pas besoin d'être globale
    int valeur_lue = analogRead(broche_capteur);

    // La suite du code
}

Le résultat obtenu est une conversion de la valeur analogique en une valeur numérique réalisée par un convertisseur analogique numérique 10 bits, contenu dans le microcontrôleur de la carte Arduino. La valeur analogique de la tension est donnée par :

La mesure prend environ 100 µs, cela fait un maximum de 10 000 mesures par seconde.

Une API c'est quoi ? En français, cet acronyme peut se traduire par : interface de programmation applicative (souvent désignée par le terme API pour Application Programming Interface). Dans notre cas, cela correspond à un ensemble de fonctions natives d'Arduino dont l'utilisateur va pouvoir se servir pour écrire un programme. (Quand on utilise des langages objet comme Java ou Python, le terme fonction est remplacé par méthode.) L'API donne une description détaillée de ces fonctions, correspondantes aux mots clés du langage de programmation et dans le meilleur des cas un exemple.

6. À partir de l'API de référence (la même en français), lire les informations données sur la fonction delay(). Pour trouver rapidement un mot dans une page web, on peut utiliser un raccourci clavier en appuyant simultanément sur les touches : Ctrl et F. Une fenêtre de saisie s'ouvre généralement en bas à gauche ou à droite (ou pas !). La valeur indiquée entre les parenthèses de la fonction est appelée paramètre. En déduire l'effet sur le programme Blink si je remplace :

void loop() {
    digitalWrite(led, HIGH);
    delay(1000);
    digitalWrite(led, LOW);
    delay(1000);
}

void loop() {
    delay(500);
    digitalWrite(led, HIGH);
    delay(2500);
    digitalWrite(led, LOW);
}

Vous pouvez également avoir la liste des fonctions liées au temps au bas de la page web correspondante à la fonction delay.

7. De même, lire les informations données par l'API sur la fonction digitalWrite.

8. Chercher une fonction permettant d'écrire un message dans le moniteur série avec un retour à la ligne. Penser à regarder du côté du module Serial.

Au lieu d'obtenir : Coucou Coucou Coucou, on aimerait avoir :

Coucou
Coucou
Coucou

9. Écrire un programme qui permet d'afficher le numéro de la ligne en cours dans le moniteur série.

0 Coucou
1 Coucou
2 Coucou
...

10. L'installation d'Arduino permet également de récupérer la totalité de l'API sur votre support de stockage. Dans votre navigateur de fichier, faites une recherche pour accéder à l'API dans un répertoire qui devrait s'intituler sketchbook/libraries/arduino/reference.

Il existe trois types de mémoire sur une carte Arduino :

• la mémoire flash est utilisée pour stocker le programme. C'est une mémoire non volatile, le programme que vous avez écrit et téléversé reste dans la mémoire même hors tension ;
• la mémoire SRAM (Static Random Access Memory) à laquelle le programme peut accéder à tout moment. C'est là que sont copiées les données initialisées par le programme pour ensuite être modifiées. C'est une mémoire volatile ;
• l'EEPROM est une mémoire non volatile à laquelle on peut accéder par les fonctions read() et write() du package EEPROM. Attention, ce type de mémoires est réservé aux utilisateurs initiés.

Pour toutes les cartes Arduino, 2048 octets de la mémoire Flash sont réservés pour le bootloader résident.

Remarque : la SRAM disponible est faible, il est préférable d'éviter les variables de type chaînes de caractères avec des chaînes trop longues. Les deux exemples ci-dessous illustrent l'espace mémoire occupé par une chaîne de caractères :

// Un programme qui ne fait rien

String s = "";

void setup() { }

void loop() { }

// Un programme qui ne fait
// toujours rien
String s = "abcd";

void setup() { }

void loop() { }

11. Copier et compiler l'exemple 5, dans la console de l'EDI Arduino, relever la taille du croquis en octets.

12. Copier et compiler l'exemple 6, dans la console de l'EDI Arduino, relever la taille du croquis en octets et en déduire l'espace mémoire occupé par un caractère de la chaîne en octets.