Rapport de Stage Badin Baptiste PDF

BADIN
Le Creusot
Baptiste
Suivi automatisé du matériel

du centre d’essais
Tuteur de stage : Alexandre LEGER

Tuteur scolaire : Pierre PAUCHARD
DUT Mesures Physiques

2016-2018
Je remercie particulièrement Arnaud SCHOENZETTER, responsable du pôle
essais, mon tuteur d’entreprise, Alexandre LEGER, responsable du laboratoire
d’essais qui m’a proposé ce sujet de stage, mais également Yoann LA-PLACA qui
m’a accompagné et aiguillé tout au long de la réalisation de ce projet, ainsi que
l’équipe des essais ; Benoît ABADIE, Thierry MALE, Antoine BADAUT, François
BAUDIN, Ali MBECHOUR, pour leurs aides et leur bonne humeur, sans qui, je ne
me serais pas aussi bien intégré dans l’entreprise.
Pour finir, je remercie également, l'IUT du Creusot, Monsieur PAUCHARD, mon

tuteur de stage et l’ensemble des enseignants pour m'avoir accompagné ces
deux années d’IUT.
BADIN Baptiste DUT Mesures Physiques 2018

1
.................................................................................................................................................. 3
1.1. Historique ........................................................................................................................................ 3
1.2. Présentation générale ..................................................................................................................... 3
1.3. Gamme de produits......................................................................................................................... 3
1.4. ALSTOM transport en France .......................................................................................................... 4
............................................................................................................... 5
2.1. Les bogies ........................................................................................................................................ 6
2.2. Le centre d’essais ............................................................................................................................ 6
................................................................................................................................ 8
3.1 Conception d’une armoire simplifiée ............................................................................................... 8
3.2 Base de données .............................................................................................................................. 9
3.3 Arduino ........................................................................................................................................... 11
3.4 Premier programme de lecture d’identifiant RFID (programme complet en Annexe 1) ............... 13
3.5 Ouverture de l’armoire .................................................................................................................. 14
............................................................................................ 15
4.1 Différentes méthodes : .................................................................................................................. 15
4.2 Analyse du matériel présent dans la boite :................................................................................... 16
4.3 Communication entre deux cartes : ............................................................................................... 17
................................................................................................................ 19
5.1 Organigramme ............................................................................................................................... 19
5.1.1 L’initialisation .......................................................................................................................... 19
5.1.2 L’identification, l’ouverture et la fermeture ........................................................................... 19
5.1.3 Le scan des objets ................................................................................................................... 19
5.1.4 Renvoie des informations ....................................................................................................... 19
5.2 Mémorisation et études des variables ........................................................................................... 20
5.3 Le programme de la carte NANO ................................................................................................... 21
5.4 Le programme principale (carte UNO) ........................................................................................... 26
5.5 Communication Armoire A Ordinateur .......................................................................................... 28
............................................................................................................................................ 30
................................................................................................................ 30
............................................................................................................................ 31

2
1.1. Historique
Le groupe Alstom a été créé en 1928. C’est le résultat de la fusion entre la SACM (Société
Alsacienne de Constructions Mécaniques) spécialiste dans la production de locomotives et de
Thomson-Houston, société franco-américaine, spécialiste des équipements de tractions
électriques et construction électro mécanique. Le nom à la création de l’entreprise est donc
ALSTHOM contraction d’Alsace-Thomson.
En 1976 ALSTHOM est racheté par le groupe ALCATEL.
Puis en 1989 se crée une alliance entre ALCATEL et GEC (General Electric Compagny).
C’est en 1998 que les deux compagnies vendent la majorité du capital Alsthom en bourse, de
part cet évènement est né ALSTOM.
Dans le début des années 2000, ALSTOM possède des parts de marché dans l’énergie, le
transport, et les chantiers navals. Mais après la crise économique de 2003, l’entreprise décide
de se départir de ses chantiers navals en 2006, et de son secteur énergie en 2014 au profit du
géant américain General Electric.
Dès lors, ALSTOM se concentre exclusivement autour de sa branche spécialisée dans le

ferroviaire : ALSTOM transport.
1.2. Présentation générale
ALSTOM conçoit et propose des systèmes, équipements et services pour le secteur ferroviaire.
La compagnie a réalisé plusieurs performances et records sur rail :
• 1990 : le TGV Atlantique bat le record de vitesse sur rail : 515,3 km/h. Il a permis de faire
connaître le TGV au monde entier. Il apparaît alors comme étant le train de l'avenir.
• 2007 : nouveau record du monde : 574,8 km/h avec la nouvelle automotrice AGV.
1.3. Gamme de produits

3
Matériel ferroviaire :
• TGV, trains pendulaires et régionaux (figure 1)
• métros, tramways
• infrastructures, signalisations, services
Figure 1 : Gamme de produits
1.4. ALSTOM transport en France
12 sites en France, avec une fonction différente chacun :
Figure 2 : Sites Alstom en France

4
Figure 3 : Localisation du site
Implanté depuis 1836, le site du Creusot participe activement à la vie locale. Il est l’un des plus
gros employeurs de la région. Le site a développé des partenariats avec l’université de
Bourgogne, en particulier avec l’IUT du Creusot et le pôle laser Bourgogne. Il est par ailleurs
membre du pôle nucléaire de Bourgogne et mène des recherches dans les domaines de la
métallurgie, de la mécanique ou encore du soudage.
Le site est dédié aux bogies, aux amortisseurs et aux freins. Ces équipes d’experts en
ingénierie, R&D, production et essais, assurent la conception puis la fabrication à
l’international de l’ensemble des matériels ferroviaires d’ALSTOM. Le site du Creusot produit
ces derniers temps, près de 45 bogies par semaine.
Etudier, Développer, Innover
Une concentration d’équipes et de budgets dédiés à la recherche et au développement est

présente sur le site d’ALSTOM le Creusot. Cela permet entre autre de concevoir et de
développer des nouveaux bogies. Des procédés de fabrication innovants (découpe et
soudage) sont également développés.
Concevoir, Fabriquer, Maintenir
Le site du Creusot possède un centre dédié à la conception, la fabrication et la maintenance

des amortisseurs équipant l’ensemble des matériels ferroviaires. Il équipe les matériels neufs
d’ALSTOM (60% de l’activité) et fournit des amortisseurs directement aux opérateurs.

5
2.1. Les bogies
Le bogie est l’interface qui permet de lier la caisse au rail (figure 5). La puissance, la vitesse, la
sécurité et le confort d'un train sont déterminés en grande partie par la qualité des bogies.
Il doit respecter les fonctions suivantes :
Supporter : C’est le rôle du châssis, il doit être conçu de façon qu’il supporte tous les organes
du bogie et la caisse. Il garantit également une sécurité et un confort maximal aux voyageurs.
Guider : Assurer une stabilité sur rail et une sécurité contre le déraillement (roues, essieux.).
Entraîner : Transmettre une puissance issue du moteur au rail, ceci entre autre par
l’intermédiaire d’un réducteur et de roues.
Ralentir : Produire un effort retardateur par friction ou électromagnétisme.
Immobiliser : Assurer une immobilisation et un isolement du train (freins).
Le site du Creusot est le centre d’excellence mondiale de la fabrication de bogies. Ils sont
produits à partir de plaques de métal brutes qui sont découpées, mise en forme puis soudées
entre elles pour former le châssis du bogie. Après l’étape de mécano soudure, le châssis reçoit
des traitements de surface puis passe à l’assemblage. C’est à cette étape de la production que
sont montées les suspensions primaires et secondaires, les boîtes d’essieux, le système de
frein, les moteurs… Chaque processus nécessite des contrôles réguliers pour s’assurer de la
qualité attendue.
2.2. Le centre d’essais
Pour pouvoir commercialiser des bogies, il est nécessaire de contrôler les différentes parties
qui composent les bogies avant et pendant sa mise en circulation, en sachant qu’ils doivent
répondre aux exigences techniques du client et aux normes de sécurité, c’est le rôle du centre
d’essais. De plus, c’est l’essai de qualification en aval qui donne de la valeur au travail de
développement en amont.
On y distingue deux catégories d’essais : les essais à poste fixe et les essais en lignes.
Les essais à poste fixes sont réalisés au centre d’essais du Creusot. Une grande partie des
pièces qui constituent le bogie sont testées ici (cf. tableau 1)

6
Quant aux essais en lignes, ils se font sur place chez les clients (aussi bien en France qu’à
l’étranger) dans le but de recontrôler certains éléments cités précédemment mais également
le confort (accélérations, vibrations, etc…).
Tableau 1 : exemples d'essais réalisés (liste non exhaustive)
Essais à poste fixes Essais en lignes

• les réducteurs (lubrification, • étanchéité
température, charge) • vibration
• Les amortisseurs (vibration, fatigue) • température
• Les freins (température, effort, • accélération
faïençage) • freins
• Les essieux
• Les châssis
De plus, le centre s’agrandit actuellement afin de pouvoir intégrer les équipements d’essais
pour les structures (châssis de bogies). Ceci s’inscrit dans la volonté de renforcer le centre
d’excellence des bogies ALSTOM au Creusot, de la conception à la fabrication en passant par
les essais de validation.
Ce centre d’essais sera accrédité ISO 17025 « Essais et validation des structure Ferroviaire ».
Cette accréditation nécessite des exigences concernant la traçabilité des moyens d’essais.
Mon stage traitera donc de la partie traçabilité des capteurs et matériel d’essais

7
En ce qui concerne le stockage de ce matériel, une majorité est stocké dans des armoires
fermées à clefs. Cela règle le problème de sécurité mais il n’y a pas de suivis de matériel ; les
employés du centre d’essais ne peuvent pas savoir si un capteur a été mal rangé, a disparu ou
est parti en essais en ligne. Il existe néanmoins un tableur Excel résultant du travail d’un
ancien stagiaire, répertoriant l’ensemble du matériel utile pour les essais, leurs
emplacements, leurs dates de validité … Cependant ce tableur devant être complété
manuellement, il n’est plus forcément à jour.
Le but du stage est donc de trouver un moyen d’obtenir un suivi de chaque capteurs dans les
armoires afin de pouvoir être informé d’où ils se situe en temps réel, et si il est utilisé.
Cependant tout le matériel du centre d’essais ne sera pas soumis à ce traçage. En effet, une
étude au préalable a été effectuer dans le but de comprendre le travail du technicien au
centre d’essais ainsi que du matériel utilisé. De ce fait, les capteurs nécessitant un étalonnage
régulier (une vérification d’un milieu extérieur pour s’assurer que le capteur délivre une
information cohérente et juste) seront les plus importants à tracer. En effet, selon les normes
imposées, un capteur doit être réétalonné toutes les années d’utilisation. Cette étalonnage a
un coup pour l’entreprise. Il y a donc un enjeu financier bien plus important qu’un enjeu
pratique.
Il sera donc nécessaire dans un premier temps de réaliser un prototype représentatif et

simplifié d’une armoire, afin de pouvoir schématiser et implémenter un premier prototype de
suivi de matériel.
Ce prototype devra communiquer avec un ordinateur, pour pouvoir lui envoyer les
informations quant au changement de place des objets de la boite.
3.1 Conception d’une armoire simplifiée

L’armoire sera prototypée grâce à une boite en plastique récupérée, de dimensions avoisinant
les 45cm/35cm/25cm.

8
Figure 4 : Extérieur de la boite
Sur la partie ouverte j’ai rajouté du plexiglass afin de pouvoir observer au travers, même
lorsque celle-ci est fermée. J’ai également séparé la boite en deux étages, en rajoutant un
plateau au milieu de la hauteur de la boite. La boite maintenant créée, pourra être modifiée à
notre guise.
L’équipement électronique sera détaillé plus tard.
Figure 5 : électronique dans la boite
3.2 Base de données

Le but du stage est de récupérer les informations en temps réels, du rangement d’une armoire
et de les enregistrer dans un tableur (Excel) par exemple-, avec comme informations : la date
et l’heure, le nom de l’employé qui a ouvert l’armoire et ce qu’il a pris ou reposé.
Pour mieux comprendre le fonctionnement logique des étapes à suivre, j’ai dressé un
organigramme répertoriant ces étapes :

9
Identification
Accès autorisé ? Accès refusé ?
Renvoie une information sur la demande d’accès
Ouverture porte
Fermeture porte
Scan des objets et envoie des modifications
Figure 6 : Organigramme des étapes à suivre

lors de l’utilisation de l’armoire
Dans un premier temps, j’ai analysé les besoins autour de l’ouverture sécurisée de la porte de
l’armoire.
Pour rentrer dans le site d’Alstom le Creusot, l’employé dispose d’une carte magnétique qu’il
doit passer devant une badgeuse afin de s’identifier.
Cette identification du personnel utilise le principe de communication RFID (Radio Frequency

Identification ou Identification par Radio Fréquence).
Elle est également utilisée pour l’accès à la deuxième partie du centre d’essais (porte
verrouillée électroniquement).
J’ai donc envisagé d’utiliser ces badges et cette technologie pour obtenir, en conséquences, le
nom de l’individu qui ouvrira la porte de l’armoire.

10
Il me fallait trouver quelque chose pour faire un lien entre la technologie RFID et le retour de
données par ordinateur.
J’ai donc choisi d’utiliser et de programmer avec Arduino.
3.3 Arduino
Arduino est une plateforme Open Source (accès libre à l’intérieur du programme et
documentation complète de tous les composants)
Elle permet donc d’écrire des programmes qui peuvent être implantés dans des cartes
électroniques
Arduino propose également des cartes électroniques programmables. Il existe différent types
de carte qui répondent chacune à différentes contraintes. Ces cartes sont très abordables
(~25 € pour la carte « basic » appelée UNO sur le site officiel Arduino mais dont le prix, peut
être nettement diminué sur d’autre site comme Amazon).
Il existe plusieurs types de cartes pour différentes utilités : nous utiliserons ici pour l’ouverture
de la porte une Arduino UNO. (Nous ne recherchons pas de la puissance importante ce qui
justifie le non choix de la gamme d’Arduino supérieur : la MEGA et nous n’utiliserons pas la
plus petite ici (NANO) pour garder de la clarté dans nos câblages).
Figure 7 : Carte Arduino UNO
En ce qui concerne la programmation d’une carte Arduino, il suffit de paramétrer

correctement la carte (choisir le bon port USB où celle-ci est branchée et choisir la bonne
carte dans les paramètres).

11
Figure 8 : Paramétrage du logiciel Arduino
lors du branchement d’une carte
Description synthétique d’un programme sous Arduino :
Le langage utilisé ici est le C++. Arduino de base possède certaine librairie pour faciliter la
programmation. Cependant nous utiliserons d’autres librairies qui devront être installées afin
de permettre à la carte de comprendre notre programme.
Les programmes sont divisés en 3 parties de bases :
•Déclaration des variables globales et appel de librairies
•La partie Setup (initialisation)
•La partie Loop (répétition infinie du programme).
Dans un premier temps, le but était de récupérer l’identifiant d’un badge Alstom quelconque.
Il me fallait donc utiliser du matériel pour lire un badge RFID.
Arduino a l’avantage d’être énormément documenté sur internet. Suite à différentes

recherches, le module de lecture le plus utilisé est le RC522 (~5€ sur Amazon).
Ce module est composé de 8 pins (également appelé broche de communication) .
Il est alimenté en 3,3V (câble rouge sur 3,3V et câble noir sur le Gnd de la UNO)
Le câble Orange (sur le RC522 est appelé MISO pour Master Input Serial Output) est relié sur
l’entrée/sortie (que j’abrégerai dorénavant en E/S) digitale 12.

12
Le câble Bleu (sur le RC522 est appelé MOSI pour Master Output Serial Input) est relié sur
l’E/S digitale 11.
Le câble Vert (sur le RC522 est appelé SCK pour Serial Clock) est relié sur l’E/S digitale 13.
Ces trois câblages sont propres au système de communication Maitre/Esclave de l’Arduino et

ne peuvent pas être intervertis ou changés de pins. De plus, si l’on utilise un autre capteur
nécessitant les pins MOSI, MISO et/ou SCK, il suffit de les brancher en parallèle.
Le pin de sélection de l’esclave est le câble Violet (SDA), c’est lui qu’il faut paramétrer dans le
programme pour que l’Arduino sélectionne ce lecteur RFID et pas un autre (en admettant que
d’autres lecteurs soient également branchés sur les E/S 11,12,13). Ces 4 câblages
représentent le protocole de communication appelé SPI.
Enfin pour le pin RST, il n’est pas forcément utile de le câbler, cependant il est également à
paramétrer dans le programme Arduino, donc si l’on ne le câble pas, il faut néanmoins lui
définir une E/S digitale non câblée (qui peut être commune à d’autres modules RFID dans le
programme).
Figure 9 : Câblage d’un lecteur RFID sur une carte UNO
3.4 Premier programme de lecture d’identifiant RFID (programme complet en

Annexe 1)
Ce programme en annexe nous permet donc d’obtenir l’adresse d’un badge.
Cette adresse est écrite sur 5 octets : il existe donc 2565 combinaisons d’adresses différentes.
(soit 1000 millards de possibilités)
L’adresse ainsi obtenue est du type 123.124.125.126.127

13
C’est donc un tableau de nombres et non une variable unique. Nous devrons faire en sorte de
la transformer en un entier du type 123124125126127.
La méthode que j’ai utilisée consiste à multiplier par 1000 l’octet de rang n et d’ajouter l’octet
de rang n+1 à chaque itérations.
𝐼𝐷 = 𝐼𝐷 × 1000 + 𝑈𝐼𝐷[𝑖]
Cependant, nous allons faire face à un problème lié à l’informatique. En effet, la taille d’une
variable de type nombre n’est pas infinie : le nombre le plus grand que l’on peut utiliser est
defini avec la variable long qui le précede. Un nombre de type long peut prendre une valeur
comprise entre -2,147,483,648 et 2,147,483,647 or ici l’ID de travail est bien supérieur à cette
limite.
Deux possibilités s’offrent à nous :
Travailler avec des variables réduites. (123124125 et on n’utilise pas 126127)
Décomposer l’ID de 5 octets en 2 variables. (123124125 et 126127)
J’ai donc choisi de décomposer en 2 variables pour conserver une plage d’ID importante.
De ce fait, on peut maintenant assimiler deux nombres à un individu et, avec des
conditions, si ces nombres appartiennent à la base de données (liste des ID des personnes
autorisées) alors on autorise l’accès.
3.5 Ouverture de l’armoire

J’ai réfléchi sur une méthode d’ouverture commandée depuis la carte Arduino.
Je me suis donc appuyé sur ce qui existait déjà dans l’entreprise ; une serrure à électroaimant.
Au vu des dimensions un peu petites de la boite, j’ai préféré utiliser seulement un
électroaimant. Il est défini par des caractéristiques sur sa consommation et sa force. J’ai choisi
un électroaimant de 12V 1A et de 60 Kg d’attraction.
Or, la carte ne permet pas de délivrer un courant aussi important (40 mA pour les E/S et 200
mA pour le VCC) et également de le commander. Nous devrons alors utiliser un relais et une
alimentation externe pour contourner ce problème.
Le but du relais est de commander un interrupteur (où il y a 12 V 1A) grâce à une entrée de
5V en amont.
Le relais alimentera donc l’électroaimant lorsqu’il est en position de repos (position 1) et une
bande de LED lorsqu’il bascule en seconde position. (La lumière intérieure de la boite ne
s’allume que lorsque le badge est validé et les portes sont ouvertes.)

14
4.1 Différentes méthodes :
Suivi par lumière. Principe : Une diode émettrice en haut et un récepteur

(photodiode/photorésistance) en dessous. Si un objet est placé entre la diode et le récepteur,
ce même récepteur ne capte plus de lumière et renvoie une information nulle.
Cette methodes n’ai pas très coûteuse et facilement instalable (seulement 4 câbles).
La détection est efficaces pour des diodes qui émettent dans un cône relativement faible.
L’un des principal défauts de cette méthode , c’est qu’elle ne permet pas de différencier deux
objets si ils sont intervertis. On pourrait donc l’utiliser pour le suivi d’objets dont on dispose
en plusieurs exemplaires (par exemple des thermocouples).Un autre défaut est que si la diode
ou le récepteur se tâche ( avec des restes d’huiles par exemple), le recepteur pourrait
renvoyer en permanence l’information qu’un objet est présent alors qu’il a été retiré.
Suivi par masse. Principe : une balance ou un système identique est placé sous chaque
emplacement d’objets et celle-ci renvoie ou non l’ information de la présence d’objet.
L’avantage, c’est qu’il permet de suivre la quantité de petites pièces (écrous/boulons).
L’inconvéniant c’est que ce système est cher, relativement complexe et peu pratique à
installer (volumineux, il faudrait une balance par objet dans l’armoire ce qui n’est pas
pratique). De plus l’étagère Visseries (petits objet en grande quantité) , ne fait pas partie des
étagères à suivre. Cette méthode est donc peu envisageable et très situationnelle.
Suivi par contact électrique. Principe : Sous chaque emplacement d’objets, se trouve un petit
interrupteur qui bascule de niveau lorsqu’il reçoit une légère pression.
Tout comme le principe de suivi par lumière, ce système est relativement facile à installer et
peu couteux
Cependant il ne permet pas lui non plus de différencier les objets présents, et certains
capteurs sont très légers et ne feront probablement pas basculer d’état l’interrupteur, cette
méthode est donc peu envisageable.

15
Suivi par badge. Principe : on place des badges RFID sous chaque objet de l’armoire et des
récepteurs RFID à l’endroit prévu pour recevoir un objet. Lorsqu’il n’y a pas d’objet, le
récepteur ne renvoie rien, et si il y’a un objet, avec un badge, alors le récepteur renvoie l’ID du
badge et en traitant cette information on peut savoir si l’objet était présent avant ou si il a été
sorti. La marge de détection est relativement bonne, l’information renvoyée est propre au
badge lu
L’un des désavantages d’utiliser les badges RFID est qu’ils ne fonctionnent pas forcément sur,
ou au travers d’une partie métalique, et que les badges peuvent être trop gros pour suivre de
petits objets (5 cm max )
J’aurrais pu envisager d’autres méthodes de détection comme la détection par GPS ou par
lecture de code barre, mais ces deux méthode ne respecte pas les contraintes fixée. Pour le
suivi GPS, les systèmes à intégrer aux capteurs seraient trop volumineux et trop chers. Alors
que pour le lecteur de CodeBarre, celui-ci ne serait pas automatique.
Récapitulons sous forme de tableau :
Méthode LUMIERE MASSE CONTACT RFID

Prix ☺☺☺ ☺ ☺☺☺ ☺
Programation ☺☺☺ ☺ ☺☺☺ ☺☺
et instalation
Efficacité ☺☺ ☺ ☺ ☺☺☺
générale
Qualité de
l’information ☺ ☺☺ ☺ ☺☺☺
renvoyé
Conclusion ☺☺☺☺ ☺ ☺☺ ☺☺☺☺
Tableau 2 : Comparaison des possibilités de traçage
J’ai donc réalisé un prototype d’armoire à deux étages, pour illustrer les deux possibilités de
détection que j’ai choisi : la lecture par badge d’un coté et par lumière de l’autre coté.
Sur l’étage supérieur j’installerai deux emplacements capables de suivre un objet possédant
un badge et sur l’étage inférieur j’utiliserai un suivi par LED et photodiode.
4.2 Analyse du matériel présent dans la boite :

L’existant : Un lecteur RFID (pour ouverture de la porte)
Une carte Arduino uno
Un relais

16
Un electroaimant ainsi qu’une alimentation assortie.
A ajouter : Deux lecteurs RFID (et des badges assortis)
Des LEDs reliées au relais pour allumer la boite lorsque celle-ci s’ouvre
Des photodiodes
Un capteur pour renvoyer à la carte l’état de la porte
Une led verte d’information, si le badge est validé.
4.3 Communication entre deux cartes :

La problématique rencontrée en utilisant Arduino est de savoir s’il est possible d’augmenter le
nombre d’entrées et de sorties sur une carte (ou de trouver une alternative à cela). En effet le
nombre de sortie digitale est limité (13+6) ce qui nous rend impossible l’utilisation de plus
d’une dizaine de lecteurs RFID. Or le but de la mission est de pouvoir suivre plusieurs armoires
et par conséqent, plus d’une centaine de badges RFID.
Une carte ne suffit plus. J’ai donc effectué des tests afin de voir s’il était possible de faire
communiquer deux cartes entre elles ; et si cela était possible, de vérifier que cela pouvait
marcher pour une infinité de cartes.
Lorsqu’une carte Arduino communique avec le PC (avec la fonction Serial.print), les deux
entrées/ sorties 0 et 1 sont bloquées. Elle n’ont plus la même fonctionalité que les autres E/S.
L’E/S 0 devient RX (pour réception de données ) et l’E/S 1 devient TX (pour transmission de

données).
Sur ces bornes est envoyés le même signal que la carte envoie à l’ordinateur par USB.
J’ai verifié que si l’on envoyait un message d’une carte A par L’ E/S TX de celle-ci sur l’autre
E/S TX de la carte B on obtenait le message de la carte A dans la console de l’ordinateur relié
par usb seulement à la carte B.
Cependant il faut prendre une précaution : la fonction Serial.begin initialise la liaison série et
« bloque » les E/S RX et TX . il faut penser à utilisé Serial.end avant de recevoir des
informations provenant d’autres cartes.
Par concéquant en plus de l’alimentation et de la liaison TX-TX il faut un autre câble

provenant d’une sortie de la carte réceptrice qui transmettra une impulsion à l’autre carte
lorsque celle-ci sera prête à recevoir des données.

17
(Carte UNO récéptrice branchée en Carte USB à un PC et Nano émétrice) :
Carte UNO
Serial.begin(9600)
Carte UNO
Serial.print(’’UNO’’)
Carte UNO
Serial.end()
Figure 10 : Ordre
des étapes de Carte UNO
communication Envoie impulsion E/S digital
entre 2 cartes (Uno
et Nano)
Carte NANO
Si impulsion reçue
alors
Serial.begin(9600)
Carte NANO
Serial.print(‘’nano’’)
Carte NANO
Serial.end()
Figure 11 : câblage entre UNO et

NANO

18
5.1 Organigramme
Le fonctionement de la boite suit un algorithme qui se répète à l’infinie. Il m’a fallu analyser
les étapes, d’une part, avant de me lancer dans la réalisation du projet.
5.1.1 L’initialisation
La toute première étape de notre algorithme consiste à la mise sous tension de la carte. Un inventaire
doit être fait automatiquement à chaque mise en tension de la boite (pour que celle-ci puisse
déterminer automatiquement quels objets ont été sortis lors de la première ouverture et fermeture de
la boite).
Initialisation 1
5.1.2 L’identification, l’ouverture et la fermeture

En ce qui concerne l’identification, se référer à 3.4 et 3.5 (p12 et p13). Après la phase
d’identification, soit le programme redemande une autre identification(si celle-ci a échoué) ou
soit la porte se dévérouille. On nous renvoie donc l’identifiant de la personne et on attends
que la porte se referme.
Identification 2
5.1.3 Le scan des objets
La porte se referme (on active l’élécroaimant) la carte uno envoie un signal à la carte nano n°1
qui va procéder à un scan.
Elle doit également garder en mémoire les ID des anciens objets présents avant l’ouverture.
(donc pour 10 emplacement RFID, cela donne 10 variables stockées avant ouverture et 10
nouvelles variables après fermeture)
Scan objets 3
5.1.4 Renvoie des informations
Tout les lecteurs RFID ont renvoyé leurs informations du nouvelle ID qu’ils captent.
La carte renvoie seulement les objets sortis ou rentrés. Renvoie d’informations 4
Elle peut renvoyer une impulsion à une autre carte nano branchée à la suite de la chaine pour
que celle-ci procède à l’étape 5.1.3 et 5.1.4.
Sinon l’algorithme redémarre à l’étape 2 : identification

19
5.2 Mémorisation et études des variables
L’objectif de la boite est de comparer les variables des objets avant l’ouverture de la boite
avec ceux d’après fermeture.
Prenons l’exemple pour deux objets A et B pouvant prendre deux états chacun :
A0 & A1 B0 & B1 0 signifie absent de la boite
1 signifie présent dans la boite
Etudions les possibilités et ce que la carte doit renvoyer pour chaque possibilité.
Etat avant identification Etat après fermeture porte Message renvoyé par NANO
A0 B0 A0 B0
A0 B1 A0 B1
A1 B0 A1 B0 Aucun changement
A1 B1 A1 B1
A1 B1 B1 A1 (position intervertie) Aucun changement
A0 B0 A1 B0
A0 B1 A1 B1 A rentré
A0 B 0 A0 B1
A1 B 0 A1 B1 B rentré
A1 B0 A0 B0
A1 B1 A0 B1 A sorti
A1 B 1 A1 B0
A0 B 1 A0 B0 B sorti
A 0 B0 A1 B1 A rentré et B rentré
A 1 B1 A0 B0 A sortie et B sortie
Tableau 3.1 : Répertoire théorique des mouvements de 2 objets dans la boite
A ces mouvements peut être rajouté 2 nouveaux objets : par exemple on peut imaginer que
lorsque A et B sont sortis, ils soit remplacés par deux nouveaux objets C et D :

20
On obtient donc :
Etat avant identification Etat après fermeture Message renvoyé par NANO
A1 B1 C0 D0 A0 B0 C1 D1 A sortie B sortie C rentré D rentré
Tableau 3.2 : Cas particulier pour 2 lecteurs RFID
Pour 2 lecteurs RFID, on obtient donc le message comportant le maximum d’informations soit
4 informations.
Pour 3 lecteurs RFID on pourait obtenir 6 informations ( 3 sorties 3 entrées)
Par concéquant, pour n lecteurs RFID on peut obtenir 2n informations au maximum

concernant le changement des objets.
5.3 Le programme de la carte NANO
La structure du programme est basée sur celle expliquée en 5.1.
Nous utiliserons donc 4 variables pour stocker les ID des objets repérés par les lecteurs.
AID1 et BID1 sont les variables représentants ce que le lecteur RFID a reçu avant
l’ouverture de la porte.
AID2 et BID2 sont les variables d’après fermeture de la porte.

21
La première partie du programme est donc l’initialisation.
Initialisation 1
Son but est de détecter dés la mise sous tension des cartes, les objets présents.
Pour ce faire on va initialiser les variables des ID à 0. Puis dans la fonction void setup(),
(fonction qui ne s’effectue qu’une fois à chaque démarrage) nous allons attribuer à nos
variables AID1 et BID1, les ID des objets présents, si il y en a de détectés, et sinon la variable
reste à 0.
Ensuite vient la partie identification :
Identification 2
La partie identification résulte du travail en amont de la carte UNO, en effet si celle-ci reçoit
un badge avec accès autorisé, alors la carte UNO envoie une impulsion à la carte NANO pour
lui demander de préparer le Scan.
Tout le reste du programme (soit l’entiereté de la fonction loop() ) dépend de si la carte reçoit
l’impulsion attendue. Par concéquant, si la carte NANO ne reçoit rien, alors elle ne fait rien.

22
Scan objets 3
On retrouve une partie similaire à l’initialisation, sauf qu’au lieu de travailler sur les variables
AID1 et BID1, on travaille maintenant sur AID2 et BID2.
Après cette partie on obtient donc 4 variables à analyser. (AID1 et BID1 pour l’état de
l’armoire avant modification , AID2 et BID2 pour après modification).
Renvoie d’informations 4

23
La première partie (les boucles if) représente les conditions. C’est la partie logique qui va
traiter les informations pour nous renvoyer l’information du changement d’objet.
Les deux premières boucles concernent les objets sorties ( la première par rapport au lecteur
RFID A et la seconde pour le B).
Pour qu’un objet soit sorti, il faut :
-qu’il soit présent dans la boite à l’état 1 (avant ouverture des portes)
-qu’il ne soit plus présent à l’état 2 sur TOUS les lecteurs de l’armoire (cela ne veux pas
dire qu’aucun objet ne doit être sur les lecteurs, mais juste que l’objet dont on compare les
variables ne soit plus dans l’armoire ; il peut par exemple être remplacé par un autre objet).
On obtient donc la condition suivante (pour savoir si l’objet présent sur le lecteur A a disparu):
Y’avait-il un objet L’objet n’est plus détecté sur tous

présent sur le lecteur les lecteurs RFID après fermeture
A avant l’ouverture? des portes ?
Si cette condition est vraie (grâce à la fonction and cela signifie que les trois conditions sont
vraies), alors la carte nous renvoie l’information que l’objet possédant de tels identifiant (ici
c’est AID1) est sorti de la boite. Le programme ne s’arrête pas là, que cette condition soit vraie
ou fausse, il va tester les trois autres.
Pour vérifier la sortie de l’objet présent sur le 2ème lecteur RFID, on reprend les mêmes
conditions mais au lieu de les tester sur le lecteur A on les teste sur le B :

B avant l’ouverture? des portes ?
Maintenant pour vérifier l’entrée d’objet on effectue l’inverse :
L’objet est détecté après L’objet était présent sur aucun des
fermeture des portes sur le lecteur lecteurs RFID avant l’ouverture
A? des portes ?

24
L’objet est détecté après L’objet était présent sur aucun des
fermeture des portes sur le lecteur lecteurs RFID avant l’ouverture
B? des portes ?
Comme expliqué précédemment : si la boite possède n lecteurs RFID , alors il y aura 2n

conditions à programmer. Ici 2 lecteurs donc 4 conditions
Imaginons que nous utiliserions 5 lecteurs RFID (A-B-C-D-E)
Les conditions précédentes deviendraient :
Pour la sortie d’objet ( lecteur A ) :

A avant l’ouverture? des portes ?
Pour l’entrée d’objet( lecteur B) :
L’objet est détecté après L’objet n’était présent sur aucun

fermeture des portes sur lecteur des lecteurs RFID avant
A? l’ouverture des portes ?
Enfin, lorsque toutes les conditions se sont effectuées et que les messages ont été envoyé à la
carte UNO, on ajoute un petit delais pour s’assurer qu’il n’y ai pas de problème de
transmission, puis on ferme les E/S RX et TX de la nano pour que celles-ci ne soit plus
influencées par les messages de toutes autres cartes branchées sur ce même câble.
Pour terminer, il faut réinitialiser les variables pour une prochaine itération :

25
Les variables AID1 et BID1 (« état de l’armoire avant ouverture ») prennent les nouvelles
valeurs de AID2 et BID2 (« état de l’armoire après fermeture »).
Enfin on remet à 0 AID2 et BID2.
La fonction loop() est donc prête à être relancée avec les nouvelles
variables mises à jours.
5.4 Le programme principale (carte UNO)
Le programme principal commence également par une partie plutôt lourde d’initialisation. En effet,
plusieurs protocoles de communication différentes sont utilisés ici (SPI pour les lecteurs RFID et I2C
pour l’horloge) ce qui rend la partie initialisation complexe.
Initialisation 1
Tous les protocoles sont initialisés et donc prêts à être utilisé.
Nous allons donc passer à la fonction void loop(

26
Identification 2
Comme expliqué précédemment j’ai dédoublé la variable reçue par le lecteur d’identification (une
variable de 5 octets à 2 variables de respectivement 3 et 2 octets).
Ensuite nous allons comparer les deux variables obtenues de telle sorte que si les variables reçues sont
celles appartenant à quelqu’un autorisé, alors on ouvre la porte, sinon on laisse fermer. C’est ici qu’il
faudra reprogrammer la carte pour autoriser de nouvelles personnes :

27
J’ai donc créé une fonction info() qui va regrouper la partie scan de l’armoire et la partie renvoie
d’information :
En effet cette fonction info() a pour but de :
-Déverrouiller l’électroaimant
-Attendre que la porte s’ouvre
-Attendre que la porte se referme
-Envoyer une impulsion à la carte NANO
-Attendre le temps de recevoir toutes les données de la NANO
-Redémarrer la fonction loop
Il est possible de modifier les conditions pour que le programme redémarre.
En effet, imaginons qu’il y ait une dizaine de cartes NANO qui communiquent chacune leur tour, alors
on pourrait faire en sorte que la dernière à envoyer son message envoie également une impulsion
lorsque son travail est terminé pour que la carte UNO redémarre sa fonction loop().
5.5 Communication Armoire A Ordinateur
L’arduino ne possède qu’un moyen de communication par défaut et c’est par cable USB
(Universal Serial Bus).

28
C’est en utilisant la fonction Serial.print() que la carte Arduino par le biais du cable usb renvoie
l’information dans la console du logiciel Arduino. Mon but ici est de récupérer ces données
pour les stocker et les enregistrer sur l’ordinateur en temps réel.
En effectuant quelques recherches, les cartes Arduino communiquent en suivant le protocole

RS 232 ( appellé port série ) lorsqu’il affiche des caractères sur la console.
J’ai donc cherché un programme permettant de lire les données d’un port serie (COM sur
Windows ).
Ce protocole permet la communication de deux élements : Cependant il faut veiller à ce que

ces deux élements aient la même configuration.
Il existe donc des logiciels sur internet permettant de charger les données recus par USB
(Serial Data logger).
J’ai cherché un logiciel analogue pour utiliser sur excel. Cependant dans un premier temps, je
n’ai pas trouver directement un logiciel mais une macro à installer. Cette macro permet de lire
et de classer les informations reçues dans le tableur, selon un protocole plutôt complexe et
peu approprié à notre utilisation.
J’ai donc préférer utiliser un Data Logger qui enregistre directement toutes les données dans
un fichier texte qui servira de base de données.
De plus, grâce aux options présentes dans excel, j’ai pu remonter les informations de la bases
de données du fichier texte dans excel afin de l analyser (Voir Annexe 5 : Guide d’utilisation
Data Logger pour Excel)
On obtient donc un fichier Excel presque autonome (à mettre à jours en un clique) retraçant
les changement des objets à l’interieur de la boite.

29
Je devais trouver une méthode afin de rendre automatique le rangement dans les armoires
du centre d’essais. Je me suis donc inspiré de tout ce que je pouvais trouver sur place (comme
les badges des employés ou le tableur de l’ancien stagiaire par exemple) afin de fabriquer une
boite analogue aux armoires présentes au centre d’essaies. Dans un premier temps j’ai
analysé toutes les possibilitées qui m’étaient proposées pour ne retenir que la meilleure et la
plus envisageable.
Cette boite répond à certaines contraintes qui m’ont été fixées. Elle s’ouvre avec le badge
ALSTOM et permet de remonter l’information de la personne l’ayant ouverte. Elle utilise
également le principe de détection RFID pour analyser les sorties et entrées des matériaux
dans la boite.
Ces informations sont traitées et remontées par cables USB à un ordinateur afin de les stocker
dans un premier temps dans un fichier texte, puis dans un second temps, triées dans un
tableur Excel.
Cependant, j’avais imaginé utiliser le principe de détection par lumières à implanter sur
l’étage du bas de l’armoire. Ayant rencontré quelques problèmes , elles ne seront
probablement pas disponibles le jour de la soutenance.
Mon stage étant prolongé de 2 semaines , mon objectif sera de pouvoir implanter un système
de détection par lumières.
La maquette représente une armoire typique de rangement que l’on peut trouver au centre
d’essais. Elle est miniaturisée et n’accepte (pour l’instant) que 2 lecteurs RFID , soit 2 objets
rangés.
Bien entendu les armoires du centre d’essais peuvent quant à elle posséder plus d’une
centaine d’objets. C’est pour cela que ma méthode de suivi par RFID peut être équipée d’une
infinité de cartes (tant que l’alimentation de toute ces cartes est suffisante). Il faut donc que
ces cartes communiquent entre elles une par une et pour cela il suffit que la carte 1, dés que
celle-ci a fini sont travail, informe la carte 2 que c’est à elle de poursuivre et ainsi de suite.
Enfin chaque carte peut supporter entre une dizaine et quinzaine de lecteurs RFID. On
pourrait donc imaginer que chaque carte gère un étage de l’armoire et que toutes ces cartes
communiquent entre elles pour faire facilement l’inventaire de l’armoire.

30
J’ai donc acquis une première véritable experience professionnelle qui m’a permis de
découvrir le travail d’une équipe d’un centre d’essais. J’ai eu la chance d’être plutôt libre dans
ma façon de travailler ce qui m’a été bénéfique pour avancer et arriver à ce résultat final.
J’ai également beaucoup appris des membres de l’équipe sur l’aspect technique et
pluridiciplinaire du travail au centre d’essais ; comme par exemple , j’ai découvert le
taraudage, et j’ai appris des techniques de soudure qui me seront bénéfiques pour mon
avenir.
Pour terminer, j’ai reçu une réponse positive pour ma candidature à l’école d’ingénieur en
électronique de PHELMA à Grenoble à la rentrée prochaine et de ce fait, ce stage sera un gros
point positif et une énorme source de motivation pour la suite, car cela m’a permis de me
rendre compte que c’est bien l’électronique qui me plait le plus.

31
ANNEXE 1 : Le programme de base de détection de badge
#include <RFID.h> //appelle de la bibliothèque relative au RC 522

#include <SPI.h> //appelle d'une bibliothèque utilisé pour la communication maître/esclave
RFID lecteurPorte(10,7); //définition des broches utiles ainsi que le nom de notre capteur rfid
//(ici le nom est lecteurPorte et il a ses broches SDA et RST branchées respectivement sur le
pin 10 et 7 de l’Arduino)
int UID[5]; // création d’un tableau de 5 entiers qui contiendra l'identifiant d'une carte
void setup() {
Serial.begin(9600); // initialisation de la communication par le port USB (d'une vitesse de
9600 baud).
SPI.begin(); // initialisation de la communication maître esclave
lecteurPorte.init(); // initialisation du module RFID
}
void loop() {
if (lecteurPorte.isCard()) {
if (lecteurPorte.readCardSerial()) { // si il y a une carte de détectée, le programme va lire
l'ID de la carte
Serial.print("L'UID est: ");
for(int i=0;i<=4;i++)
{
UID[i]= lecteurPorte.serNum[i];
Serial.print(UID[i]); // affiche dans la console un octet de l'ID et répète avec for
Serial.print(".");
}
Serial.println("");
}
lecteurPorte.halt(); // fin d'utilisation des pins dédiés au module RFID (le 10 et le 9 ).
}
delay(100); // attendre 100ms pour une clarté dans l'affichage
}

32
ANNEXE 2 : Le programme complet de la carte UNO
#include <SPI.h> //bibliothèque rfid

#include <RFID.h> //bibliothèque rfid
RFID lecteurPorte(10,7); //lecteur RFID porte
#include <Wire.h>
#include <ds3231.h>
struct ts t; //déclaration variable t
int UID[5]; // taille de l'ID : 5 octets
void setup() {
pinMode(2,OUTPUT); // pin 2 = commande du relais
digitalWrite(2,HIGH); // Bloque le relais pour fermeture de la porte à l'initialisation
pinMode(3,OUTPUT); // Pin de communication de la nano
pinMode(4,INPUT); // Pin d'état de la porte
digitalWrite(3,LOW); // On s'assure que le message envoyé à la nano est nul
Serial.begin(9600); // On ouvre la communication par la liaison série
SPI.begin();
Serial.println("Connexion armoire réussie");
lecteurPorte.init(); // On initialise le lecteur rfid à la carte
Serial. End();
Wire.begin();
DS3231_init(DS3231_INTCN);
}
void loop() {
Serial.begin(9600);
long ID1=0;
long ID2=0; //déclaration des deux sous ID et Remise à zéros
if (lecteurPorte.isCard()) {
if (lecteurPorte.readCardSerial()) {
{
int IDt1=UID[i];
ID1=ID1*1000+IDt1;
}
for(int i=3;i<=4;i++){

33
int IDt2=UID[i];
ID2=ID2*1000+IDt2;}
heure();
Serial.print(" ");
Serial.print("L'identifiant est :");
Serial.print(ID1);
Serial.print(ID2);
Serial.print(" , ");
}
lecteurPorte.halt();
}
if (ID1==190090162 and ID2==241183) {
Serial.print("Baptiste BADIN,");
info(); }
else if (ID1==206116166 and ID2==241237) {
Serial.print("Alexis SAUNIER,");
info();}
else if (ID1==222008113 and ID2==241086) {
Serial.println("Nicolas AGUETTAZ,");
delay(2500);}
else if (ID1 !=0 and ID2 !=0){
Serial.println("inconnu : accès refuse, ");
delay(2500);} void heure() {
Serial.end();
DS3231_get(&t);
if (t.mday<10){Serial.print("0");}
Serial.print(t.mday);
} Serial.print("/");
void info() { if (t.mon<10){Serial.print("0");}
digitalWrite(2,LOW); Serial.print(t.mon);
while(digitalRead(4)== HIGH){ Serial.print("/");
delay(10) ;} Serial.print(t.year);
Serial.end(); Serial.print(" , ");
while(digitalRead(4)== LOW){ if (t.hour<10){Serial.print("0");}
delay(1);} Serial.print(t.hour);
digitalWrite(2,HIGH); Serial.print(":");
digitalWrite(3, HIGH); if (t.min<10){Serial.print("0");}
digitalWrite(3,LOW); Serial.print(t.min);
delay(500); Serial.print(".");
Serial.begin(9600); if (t.sec<10){Serial.print("0");}
Serial.println(); } Serial.print(t.sec);
Serial.print(" , "); }

34
ANNEXE 3 : Le programme complet de la carte NANO
#include <SPI.h> //bibliotèque rfid

#include <RFID.h> //bibliotèque rfid
RFID A(10,5); //lecteur rfid porte
RFID B(9,5); //lecteur rfid porte
int UID[5];
long AID1=0; // définition des 4 variables d’état des lecteurs RFID

long AID2=0;
long BID1=0;
long BID2=0;
void setup(){
SPI.begin(); // initialisation de la communication SPI
A.init(); // initialisation lecteur A
B.init(); // initialisation lecteur B
pinMode(3,INPUT); // initialisation de la pin pour l’entré du signal de la carte UNO
if (A.isCard()) { //Début de lecturs des données pour le lecteur A
if (A.readCardSerial()) {
for(int i=0;i<=2;i++) {
UID[i]=A.serNum[i];
AID1=AID1*1000+UID[i] ; }
}
A.halt();}
if (B.isCard()) { //Début de lecturs des données pour le lecteur B
if (B.readCardSerial()) {
for(int i=0;i<=2;i++) {
UID[i]=B.serNum[i];
BID1=BID1*1000+UID[i];}
}
B.halt();}
}
void loop(){
if (digitalRead(3)==HIGH){ //Si la carte recoit le signal de commande, alors …
Serial.begin(9600);
if (A.isCard()) { //Début de lecturs des données pour le lecteur A
if (A.readCardSerial()) {
{
UID[i]=A.serNum[i];
AID2=AID2*1000+UID[i];}
}
A.halt();}
else{
AID2=0;}
delay(10);

35
if (B.isCard()) { //Début de lecture des données pour le lecteur B
if (B.readCardSerial()) {
for(int i=0;i<=2;i++){
UID[i]=B.serNum[i];
BID2=BID2*1000+UID[i];}
}
B.halt();}
else{
BID2=0 ; }
teste() ; //On appelle on fonction qui se trouve en fin de programme
delay(50);
Serial.end();
BID1=BID2; //On réinitialise les variables
AID1=AID2;
BID2=0;
AID2=0;}
}
void teste(){
if ((AID1!=0) and (AID1!=AID2)and (AID1!=BID2)){

Serial.print(AID1);
Serial.print(" Sortie, ");}
else{}
if ((BID1!=0) and (BID1!=AID2)and (BID1!=BID2)){

Serial.print(BID1);
Serial.print(" Sortie, ");}
else{}
if ((AID2!=0) and (AID2!=AID1)and (AID2!=BID1)){
Serial.print(AID2);
Serial.print(" Entré, ");}
else{}
if ((BID2!=0) and (BID2!=AID1)and (BID2!=BID1)){
Serial.print(BID2);
Serial.print(" Entré, ");}
else{}
}

36
Annexe 4 : Câblages dans la boite

37
Annexe 5 : Guide d’utilisation
Data Logger pour Excel
But du logiciel : Récupérer les données reçus
par le port USB sous forme de tension, les
traduire sous forme de caractère ASCII puis les
enregistrer sur un fichier texte.
Interface :
Afin de récupérer correctement les données reçues, la connexion série doit être paramétrée
de la même façon du côté de l’émetteur que du récepteur.
Baudrate : C’est le nombre de bits par seconde paramétrés dans le programme ARDUINO. J’ai
paramétré à 9600 des deux côtés par défauts.
Le data bits, la parité et le Stop bits ne sont pas

paramétrables du côté de l’ARDUINO, par conséquent on
ne modifiera pas ces paramètres.
Ensuite on choisit le fichier .txt qui servira de base de données ; et l’on coche ꙱Append to file
Enfin pour terminer on sélectionne le port où la carte est branchée.

On peut maintenant effectuer la connexion.

38
Lecture de la base de données :
Les données sont enregistrées chronologiquement du haut vers le bas (chaque nouvelle ligne
est écrite en bas). Pour rechercher plus facilement le nom d’une personne ou l’état du
capteur : on dispose, du raccourci Alt+F qui nous ouvre une console permettant de chercher
dans la base de données, un mot spécial.

39
Pour passer du fichier .txt à un fichier excel , il faut :
Créer un nouveau fichier Excel.
Selectionner l’onglet Données , puis À partir d’un fichier texte/CSV
Une fenêtre s’ouvre et demande de lui indiquer l’emplacement du fichier texte.
Selectionner le fichier en question puis valider.
Vérifier que tout les paramètres coïcident avec ceux-ci, puis valider en cliquant sur charger.
Création d’une macro pour actualiser automatiquement :
Aller dans l’onglet developpeur :
S’il n’est pas disponible il faut l’activer : Fichier -> Options

40
Cliquer sur personnaliser le ruban puis tout à droite cocher la case développeur
Dans l’onglet Développeur, cliquer sur Enregistrer une macro, donner lui un nom puis valider
en appuyant sur OK :

41
La macro est en cours de fabrication, elle va répertorier toutes les actions jusqu’au moment
où on lui demandera d’arrêter.
Cliquer sur une case du tableau précédemment créée, puis aller dans l’onglet Création et
cliquer sur actualiser tout.
Enfin, terminer l’enregistrement de la macro en cliquant en bas à gauche, sur le carré.
Maintenant on va créer un bouton sur l’écran pour que lorsque l’on clique dessus ça lance la
macro que l’on vient de faire.
Dans l’onglet Développeur ->Insérer
Choisir la première forme proposée. Ensuite sur le tableur, rester appuyer avec le clique
gauche pour former un rectangle, puis relâcher le bouton de la souris.

42
Une fenêtre s’ouvre :
Sélectionner la macro que vous venez de créer puis OK. On peut créer toute sorte de macro
comme par exemple une macro qui classe par ordre chronologique les données.

43

Rapport de Stage Badin Baptiste PDF

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Rapport de Stage Badin Baptiste PDF

Transféré par

Droits d'auteur :

Formats disponibles

BADIN

Suivi automatisé du matériel

Tuteur de stage : Alexandre LEGER

DUT Mesures Physiques

Pour finir, je remercie également, l'IUT du Creusot, Monsieur PAUCHARD, mon

BADIN Baptiste DUT Mesures Physiques 2018

BADIN Baptiste DUT Mesures Physiques 2018

En 1976 ALSTHOM est racheté par le groupe ALCATEL.

Dès lors, ALSTOM se concentre exclusivement autour de sa branche spécialisée dans le

1.2. Présentation générale

La compagnie a réalisé plusieurs performances et records sur rail :

1.3. Gamme de produits

BADIN Baptiste DUT Mesures Physiques 2018

• TGV, trains pendulaires et régionaux (figure 1)

• infrastructures, signalisations, services

Figure 1 : Gamme de produits

1.4. ALSTOM transport en France

12 sites en France, avec une fonction différente chacun :

Figure 2 : Sites Alstom en France

BADIN Baptiste DUT Mesures Physiques 2018

Etudier, Développer, Innover

Une concentration d’équipes et de budgets dédiés à la recherche et au développement est

Concevoir, Fabriquer, Maintenir

Le site du Creusot possède un centre dédié à la conception, la fabrication et la maintenance

BADIN Baptiste DUT Mesures Physiques 2018

Il doit respecter les fonctions suivantes :

Ralentir : Produire un effort retardateur par friction ou électromagnétisme.

Immobiliser : Assurer une immobilisation et un isolement du train (freins).

2.2. Le centre d’essais

BADIN Baptiste DUT Mesures Physiques 2018

Tableau 1 : exemples d'essais réalisés (liste non exhaustive)

Essais à poste fixes Essais en lignes

BADIN Baptiste DUT Mesures Physiques 2018

Il sera donc nécessaire dans un premier temps de réaliser un prototype représentatif et

3.1 Conception d’une armoire simplifiée

BADIN Baptiste DUT Mesures Physiques 2018

L’équipement électronique sera détaillé plus tard.

Figure 5 : électronique dans la boite

3.2 Base de données

BADIN Baptiste DUT Mesures Physiques 2018

Accès autorisé ? Accès refusé ?

Renvoie une information sur la demande d’accès

Scan des objets et envoie des modifications

Figure 6 : Organigramme des étapes à suivre

Cette identification du personnel utilise le principe de communication RFID (Radio Frequency

BADIN Baptiste DUT Mesures Physiques 2018

J’ai donc choisi d’utiliser et de programmer avec Arduino.

Figure 7 : Carte Arduino UNO

En ce qui concerne la programmation d’une carte Arduino, il suffit de paramétrer

BADIN Baptiste DUT Mesures Physiques 2018

Description synthétique d’un programme sous Arduino :

Les programmes sont divisés en 3 parties de bases :

•Déclaration des variables globales et appel de librairies

•La partie Setup (initialisation)

•La partie Loop (répétition infinie du programme).

Arduino a l’avantage d’être énormément documenté sur internet. Suite à différentes

Ce module est composé de 8 pins (également appelé broche de communication) .

BADIN Baptiste DUT Mesures Physiques 2018

Ces trois câblages sont propres au système de communication Maitre/Esclave de l’Arduino et

Figure 9 : Câblage d’un lecteur RFID sur une carte UNO

3.4 Premier programme de lecture d’identifiant RFID (programme complet en

(soit 1000 millards de possibilités)

L’adresse ainsi obtenue est du type 123.124.125.126.127

BADIN Baptiste DUT Mesures Physiques 2018