Physique expérimentale avec Phoenix et Python

1. Qu'est-ce que Phoenix ?

Le Phoenix Project [1] est le résultat des travaux de B. P. Ajith Kumar, un chercheur qui travaille avec le Nuclear Science Centre, en Inde [2]. Ajith décrit Phoenix comme de la physique avec des équipements « maison » et des expériences innovantes. La physique expérimentale moderne fait appel à un large éventail d'équipements complexes interfacés avec des ordinateurs polyvalents. Les données recueillies par ces équipements sont introduites dans la machine à l'aide de « matériel d'acquisition de données » coûteux (la plupart du temps des convertisseurs analogique->numérique à haute vitesse) où elles sont analysées par des outils mathématiques sophistiqués. La pratique courante de l'enseignement de la physique des étudiants préparant une licence (au moins dans la partie du monde où je vis) ne manifeste qu'un intérêt de pure forme à cet aspect important de la formation d'un physicien en incorporant un exposé sur la « programmation C » et/ou les « microprocesseurs » au programme. L'objectif du Phoenix Project est de changer la situation pour l'améliorer, en donnant aux élèves des écoles/lycées une occasion d'utiliser l'ordinateur pour observer et analyser des phénomènes réels.

Permettez-moi de vous présenter deux exemples simples. Le temps de mesure est une notion fondamentale dans beaucoup d'expériences. Supposez que vous souhaitiez mesurer le temps de vol d'un objet soumis à la pesanteur. Vous notez le moment exact où il chute et vous mesurez également le moment où il frappe le sol. Une petite boule en acier peut être facilement saisie par un électro-aimant qui est activé par le port parallèle du PC. La boule peut être relâchée en désactivant la bobine (il suffit d'une simple instruction out sur le port parallèle). Quand la boule frappe le « sol », on peut lui faire fermer/ouvrir une sorte de « contact » connecté à une broche d'entrée du port parallèle. Quelques lignes de code qui mesurent le moment où une broche de sortie du port parallèle désactive la bobine et le moment où une broche d'entrée change d'état devraient être suffisantes pour vérifier un principe de physique important. Consultez ce document ici.

Quelles sont les principales pierres d'achoppement de la présentation d'une telle expérience ?

• Le temps et l'effort nécessaires pour la construction du matériel additionnel (dans ce cas, le buffer des broches du port parallèle pour le rendre capable de commander des bobines de relais).

• L'effort nécessaire pour l'écriture du code de bas niveau. L'E/S du port parallèle et les mesures de temps sont triviaux pour le programmeur expérimenté mais peuvent submerger les étudiants qui ont eu très peu d'expérience préalable aussi bien en programmation qu'en électronique.

À titre d'autre exemple, dans la théorie de base des circuits, nous nous familiarisons avec la manière dont se comportent les réseaux de résistance-condensateur. Un convertisseur analogique->numérique sur 8 bits peu coûteux connecté au port parallèle et l'échantillonnage périodique de la tension sur le condensateur produira des quantités de nombres que l'on peut analyser pour se faire une meilleure idée du comportement des réseaux RC (Resistor Capacitor, résistance-condensateur). Là encore, les principales contraintes impliquées ici sont de mettre en place le circuit CAN (convertisseur analogique->numérique) et d'écrire des programmes de mesure. Il y a une solution — acheter du matériel et des logiciels d'acquisition de données disponibles dans le commerce, mais ce n'est pas forcément attractif en raison des dépenses entraînées.

2. L'approche de Phoenix

Pour que les expériences de physique basées sur l'informatique deviennent réalité dans nos laboratoires scolaires, nous avons besoin :

• De matériel peu coûteux construit avec des composants disponibles sur le marché local. La conception devra être disponible librement et devra être assez simple pour que les étudiants en comprennent tout, s'ils le souhaitent.

• D'un ensemble d'expériences que les étudiants peuvent essayer sans construire de circuits électroniques additionnels. Trop de complexité au début peut décourager une partie du public visé (tandis que d'autres pourraient le prendre comme un défi  !).

• D'un ensemble d'outils logiciels qui offrent une courbe d'apprentissage graduelle ; le code source doit être disponible librement et les étudiants motivés encouragés à le lire et à le remanier. La plate-forme de choix est sans aucun doute GNU/Linux et les langages de programmation seront C et Python.

3. Matériel de Phoenix

Voici une image du kit entièrement assemblé :

Le matériel se compose :

• De huit broches numériques de sortie.

• De quatre broches numériques d'entrée.

• De quatre broches de commande de moteur pas à pas. Elles peuvent servir à commander des bobines de relais également.

• D'un convertisseur analogique->numérique 8 canaux 8 bits.

• D'une alimentation en tension programmable, capable de générer des tensions dans la plage +5V à -5V.

Outre ces éléments « programmables », le dispositif contient aussi les unités suivantes, ce qui simplifie l'interfaçage :

• Des blocs d'amplificateur.

• Une alimentation constante en courant.

• Un générateur de fonctions de fréquences (à ondes sinusoïdales, triangulaires, carrées).

Un schéma de principe est disponible ici. Vous pouvez suivre ce lien pour lire une description détaillée du fonctionnement de chacune des unités fonctionnelles. Des schémas de circuit complets, avec topologie de PCB (Printed Circuit Board, carte de circuit imprimé) prêts à l'emploi, sont également disponibles sur la page d'accueil du projet. La conception est pratiquement stable ; quelques boîtiers ont été fabriqués et distribués à fins de test.

4. Logiciels de Phoenix

Toutes les unités programmables du kit Phoenix peuvent être manipulées en exécutant quelques instructions in/out sur le port parallèle. Deux des aspects à prendre en charge étaient :

• Que les utilisateurs ne devraient avoir besoin d'aucun privilège spécial pour accéder au matériel.

• Qu'il devrait être possible de faire des mesures raisonnablement précises de l'ordre de moins d'une milliseconde.

Trois approches ont été identifiées :

• Faire tout dans l'espace utilisateur, non en temps réel.

• Faire tout dans l'espace utilisateur, mais en temps réel (par exemple via RTAI/LXRT (Real Time Application Interface/LinuX Real Time).

• Placer le code dans le noyau, comme un pilote « propre ».

La troisième approche s'est avérée relativement meilleure. Les utilisateurs n'auront besoin d'aucun privilège spécial, et le code du noyau est garanti ne pas être perturbé par d'autres processus (les boucles actives de mesure de gestion du temps dans le noyau gèleront le système, mais dans presque tous les cas, nous avons besoin de boucles très courtes inférieures à la seconde ; ce n'est donc pas un gros problème).

Un programme de pilote témoin (encore en phase expérimentale !) peut être téléchargé ici. Vous observerez que la majeure partie du code est une seule fonction ioctl géante qui sait faire des choses comme définir les broches numériques de sortie, lire la valeur sur les broches d'entrée, définir la tension sur l'alimentation en tension programmable, lire l'CAN, mesurer le temps entre un front montant et un bord tombant [3] sur une broche numérique d'E/S, etc.

5. Phoenix et Python

Un des avantages de placer le code du pilote sensible à la gestion du temps dans le noyau est que maintenant, il devient possible pour nous d'interagir avec le matériel via un langage comme Python, que l'on ne peut normalement pas employer pour le travail en temps réel. Étant fan de Python, une de mes premières réalisations avec le boîtier de Phoenix a été d'essayer d'écrire une bibliothèque Python simple pour dialoguer avec le matériel. Mon intention était de pouvoir faire des choses comme :

>>> from phoenix import *
>>> p = Phoenix() # Nous avons  un 'objet phoenix'
>>> p.set_voltage(2000) # Fixer la sortie DAC à 2000 mV
>>> p.select_adc(0) # Sélectionner le canal CAN 0
>>> p.zero_to_5000() # Numériser la tension sur le canal 0 et renvoyez la valeur entre 0 et 5000 mV

Une telle interaction, qui donne des retours immédiats, pourrait être le commencement de la meilleure introduction de l'étudiant au dispositif.

D'ailleurs, il est intéressant de voir comme il est facile (et naturel) d'utiliser Python pour faire de l'informatique sophistiquée (programmation fonctionnelle, lambda-calcul, fermetures...) et normale, les pieds sur terre, avec l'interaction du système d'exploitation, comme représenté dans l'extrait ci-dessus. Le code source du module Python (expérimental !) est disponible ici. Les lecteurs pourraient être intéressés par l'utilisation du module fcntl, ainsi que les modules struct et array pour effectuer les opérations ioctl requises pour commander le dispositif.

6. Expériences !

Le matériel de Phoenix, tout comme les logiciels, fournit une infrastructure générale pour un interfaçage et une expérimentation aisés. Je vais décrire deux expériences très simples que j'ai conduites avec le boîtier. La page d'accueil du projet donne plus d'explications — l'une d'entre elles concerne une expérience intéressante et simple avec un pendule, que vous pouvez consulter ici. La conception d'autres expériences est un des domaines où une communauté d'enseignants et de développeurs peut contribuer énormément.

from phoenix import *
p = Phoenix()
p.write_motors(0xf) # Exciter les broches du pilote de moteur pas à pas
t = p.get_drop_time() # Faire tomber la boule et noter l'heure !
print t

from phoenix import *

p = Phoenix()
p.select_adc(0)
# 1000 points, 2 ms delay between reads
r = p.trig_read_block(1000, 2000)
for val in r:
        print val[0], val[1]

7. Orientation future

Le Phoenix Project vient juste de sortir du laboratoire. Pour devenir un succès, comme n'importe quel projet de logiciel ou de matériel libre, il doit pouvoir attirer une communauté de fervents — des enseignants et des étudiants en sciences, des amateurs d'électronique, des geeks Linux, des développeurs de matériel... Quantités de logiciels doivent être écrits et de nouvelles expériences conçues. J'espère que cet article contribuera, à son modeste niveau, à l'implication de la communauté. N'hésitez pas à me contacter si vous voulez en savoir plus sur le projet ou si vous souhaitez organiser un atelier ou une démonstration. Suivez ce lien pour contacter le développeur de Phoenix et savoir comment obtenir le matériel et les logiciels.

Je suis formateur et travaille pour IC Software® à Kerala (Inde). J'aurais aimé travailler dans le domaine de la chimie organique, mais je donne le meilleur de moi-même à ma seconde passion, jouer avec Linux et enseigner la programmation !