Conception d’un pèse assiette débiteur de repas sur badge …darty30.free.fr/iut claude bernard/compte rendu/rapport... · 2011-06-16 · Conception d’un pèse assiette débiteur

THEROND Quentin

Année 2010/2011

Conception d’un pèse assiette débiteur de repas sur badge

magnétique ou carte RFID.

Rapport de stage d’Institut Universitaire de Technologie

Génie électrique et informatique industrielle.

Symotronic Université Claude Bernard Lyon 1

75 Rue Francis de Préssensé 17 rue de France

69100 VILLEURBANNE 69627 Villeurbanne

Tuteur de stage : Mr Stéphane MENARD

Enseignant tuteur : Mr Julien VIAL

Stagiaire : Mr Quentin THEROND

Rapport de stage Quentin THEROND 2011 Page 2 sur 73

2011

Rapport de stage

Thème : Conception d’un pèse assiette débiteur de repas sur un badge magnétique ou une

carte RFID.

Entreprise : SYMOTRONIC

Adresse : Parc République

75 rue Francis de Préssensé

69100 Villeurbanne

Téléphone : 04 72 43 00 55

Centre de formation : Université Claude Bernard Lyon 1

Département Génie Electrique et Informatique Industrielle

Adresse : 17 rue de France

69627 Villeurbanne cedex

Téléphone : 04 72 65 53 53

Etudiant : THEROND Quentin

Tuteur de stage : Mr MENARD Stéphane

Enseignant tuteur : Mr VIAL Julien

Stage de 10 semaines effectué du 18 avril au 24 juin 2011


Remerciements

Je tiens à remercier tout particulièrement mon tuteur de stage Monsieur Stéphane

MENARD, qui m’a proposé un sujet de stage ambitieux et qui a pris le temps de

m’accompagner avec bienveillance dans mon projet. Toujours disponible pour répondre à mes

questions, j’ai été sensible à la confiance qu’il m’a accordée et à l’autonomie qu’il m’a

laissée. Ce projet complète pleinement la formation dispensée par l’IUT.

Je souhaite également remercier tous les collaborateurs de SYMOTRONIC et

Monsieur Marc PURAVET pour leur accueil et pour m’avoir rapidement intégré dans leur

entreprise pendant ce stage de fin d’étude.

Enfin je remercie tous les professeurs de L’IUT Claude Bernard Lyon1, qui, par leur

engagement et la qualité de leur enseignement, m’ont permis de me doter d’une formation

complète dans le domaine de l’électricité et de l’informatique industrielle.


Sommaire

I) Préface …………… 6

II) Présentation de l’entreprise …………… 7

III) Cahier des charges …………… 9

IV) Etude générale et technique …………… 10

V) Développement technique 1ère

partie : Contexte technique ...……… 15

VI) Développement technique 2ème

partie : Etape de la réalisation..… … 18

Conception du schéma …………… 19

Alimentation …………… 21

Pont de Wheatstone …………… 22

Traitement du signal …………… 22

Eeprom …………… 25

Horloge temps réel …………… 26

Afficheur …………… 26

Microcontrôleur …………… 28

Buzzer …………… 28

Programmation …………… 20

Communication RS232 …………… 30

Typon …………… 30

Programmation …………… 31

VII) Développement technique 3ème

partie : Tests / suivi / évolution…… 37

VIII) Conclusion technique …………… 41

IX) Bilan personnel …………… 41

X) Annexes …………… 42


Table des illustrations

Figure1 : Plan ………………………… 7

Figure 2 : Organisation de la société ………………………… 8

Figure 3 : Présentation du groupe AGAPES ………………………… 9

Figure 4 : Diagramme sagittal ………………………… 10

Figure 5 : Pièce d’aluminium pour les jauges ………………………… 11

Figure 6 : Balance vue du haut ………………………… 11

Figure 7 : Photo de la jauge choisie ………………………… 12

Figure 8 : Lecteur RFID utilisé ………………………… 13

Figure 9 : Carte MIFARE ………………………… 14

Figure 10 : Protocole MIFARE ………………………… 14

Figure 11 : Trams ………………………… 14

Figure 12 : Schéma fonctionnel ………………………… 15

Figure 13 : 2ème

schéma réalisé (utilisé pour le prototype) ………………………… 18

Figure 14 : ARES ………………………… 20

Figure 15 : Alimentation ………………………… 21

Figure 16 : jauge de contrainte en pont ………………………… 22

Figure 17 : Traitement de signal ………………………… 22

Figure 18 : Sans condensateur ………………………… 23

Figure 19 : Avec condensateur ………………………… 24

Figure 20 : Simulation, réalisé avec d’autre valeur ………………………… 24

Figure 21 : Traitement de signal ………………………… 24

Figure 22 : Droite de Vud en fonction du poids ………………………… 25

Figure 23 : EEPROM & horloge temps réel ………………………… 25

Figure 24 : LCD ………………………… 26

Figure 25 : Microcontrôleur ………………………… 27

Figure 26 : Buzzer ………………………… 28

Figure 27 : Programmation ………………………… 29

Figure 28 : MAX232 ………………………… 29

Figure 29: Typon top copper ………………………… 30

Figure 30 : Typon bottom copper ………………………… 30

Figure 31 : Typon bottom copper ………………………… 30

Figure 32 : Typon 3D ………………………… 30

Figure 33 : Typon en simple face ………………………… 31

Figure 34 : Typon final double face top copper et bottom copper ………………………… 31

Figure 35 : MPLAB ………………………… 31

Figure 36 : ICD2 ………………………… 31

Figure 37 : Algorithme et description du programme principal (main) ………………………… 32

Figure 48 : Algorithme ………………………… 33



Figure 41: Algorithme ………………………… 34

Figure 42 : Tableau de commande ………………………… 35



Figure 45 : Câblage du prototype ………………………… 37

Figure 46 : Câblage du prototype zoom ………………………… 37

Figure 47 : Ecran principal ………………………… 38

Figure 58 : Détection badge ………………………… 38

Figure 59 : Détection d’un mauvais badge ………………………… 39

Figure 50 : Réglage de l’heure ………………………… 39

Figure 51 : Le plateau de la balance ………………………… 40


I) Préface

Ce dossier a pour objet de présenter le travail que j’ai effectué pendant les 10 semaines

de stage de fin de formation à l’IUT département Génie Electrique et Informatique

Industrielle. Il contient toutes les informations importantes sur l’entreprise et le projet. Ce

projet, réalisé pour le compte d’une entreprise commerciale, doit rester autant que possible

confidentielle.

Stéphane MENARD m’a confié la conception d’un projet commandé par l’entreprise

SALADE & CO. L’objet de la commande est de monter un dispositif capable de compter des

assiettes par un système de pesée et de débiter un ou plusieurs menus en fonction du nombre

d’assiettes prises par le client.

L’intérêt de ce projet résidait dans l’intégration des technologies analogiques et

numérique et dans l’apport de la mécanique de précision et de la programmation de

microcontrôleur dans un même dispositif

Dans un premier temps j’ai commencé à rédiger le cahier des charges comme me

l’avait proposé mon tuteur et dans un deuxième temps j’ai construit le planning de mon stage.

Cela m’a permis d’avoir une bonne vision de mon travail et de bien m’organiser. J’ai utilisé le

modèle en V vu en cours pour réaliser ce projet.

J’ai deux semaines pour trouver les

composants à utiliser, deux semaines

pour faire le schéma et le typon, trois

semaines de programmation pour

réaliser le code et pour finir, trois

semaines pour réaliser les tests et les

modifications. Le planning ci-dessous

représente les grandes taches du projet.


II) Présentation de l’entreprise

SYMOTRONIC :

SY pour système

MO pour monétique

TRONIC pour électronique

Figure1 : Plan

L’entreprise SYMOTRONIC, située à Villeurbanne, a été fondée en 1996 par Marc

PURAVET.

Cette entreprise spécialisé dans les systèmes de paiement cashless* à technologie

Mifare. Elle est devenue le distributeur officiel de la gamme MICROTRONIC (Suisse) et

travaille en coopération avec CIB, entreprise rachetée par Monsieur Marc PURAVET.

Grâce à la mise en œuvre de la Technologie Mifare (Philips NXP), SYMOTRONIC intervient

dans de nombreux domaines où l’utilisation d’un badge d’accès est requise. Porte-monnaie

électronique, accès payants, accès normal, photocopieur, restauration... Elle effectue l’étude et

la réalisation de solutions de logiciels et matériels adaptés à la monétique et à son

environnement proche (restauration collective, contrôle d'accès, gestion du temps,

réévaluateur carte Bancaire, télémétrie, etc.).

SYMOTRONIC est une SAS (Société par Action Simplifiée) dont les 98% sont

détenus par Monsieur PURAVET. Son chiffre d’affaires est de 3.064.000€ en 2011 et son

capital social de 40 000€. L’exportation représente 1% du chiffre d’affaires de l’entreprise.

SYMOTRONIC réalise la majorité de son chiffre d’affaires dans les systèmes

cashless* pour le vending** c'est-à-dire les systèmes de paiement électronique pour la

distribution automatique. C’est un domaine où elle s’est imposée comme une entreprise de

confiance ayant de l’expérience et étant capable de fournir des systèmes fiables.

*Cashless : Système de paiement électronique.

**Vending : distribution automatique.


Cette entreprise compte actuellement 9 salariés qui sont :

Figure 2 : Organisation de la société

Effectif :

Mr Marc PURAVET : Directeur de Symotronic (Ingénieur)

Mr Stéphane MENARD : Responsable technique (Ingénieur)

Mr Patrice BARLET : Chargé d’affaire (Ingénieur)

Mr Francis RIBEIRO : Technicien électro-informaticien (technicien)

Mr Matthieu MINGAS : Technico électro-informaticien (technicien)

Mr Philippe AUGOYAT : Développeur informatique (technicien)

Mr David BARAILLY : Développeur web (technicien)

Mr Sylvain CHAPELLUT : Technico électro-informaticien (technicien)

Mr Cyril MATHIEU : Ingénieur en apprentissage (technicien)

Mme Siham MERAÏ : Comptable DECF à mi-temps

Information sur l’entreprise :

Compagnie : SYMOTRONIC

Capital : 40.000€

Chiffre d’affaires : 3.064.000€

Siège : Parc République, 75 Rue Francis de Préssensé 69100 Villeurbanne

Téléphone : 04 72 43 00 55

Fax : 04 72 43 00 27

Web : www.symotronic.com

Mail : [email protected]

mailto:[email protected]


III) Cahier des charges

3.1) Introduction

Le but du système que l’on ma confié est de débiter un ou plusieurs menus en fonction du

nombre d’assiettes que l’utilisateur aura prises sur le plateau. Ce développement a été

commandé par SALADE & CO qui fait partie du groupe AGAPES. Ce groupe possède touts

les enseignes suivantes :

Figure 3 : Présentation du groupe AGAPES

3.2) Description du système

La première étape devra être le calibrage de la partie pesage des assiettes. Une fois le

calibrage effectué, les utilisateurs pourront prendre une ou plusieurs assiette(s). Si le badge est

à sa place le système, le système débitera un ou plusieurs menus. Si le badge n’est pas à sa

place, alors le système devra commander un bip d’avertissement et l’afficheur devra indiquer

qu’il faut soit reposer l’assiette soit mettre un badge. La recharge d’assiettes sera possible

uniquement avec un badge prévu pour l’accès au menu du système. Le protocole de

communication aura besoin d’une horloge temps réel.

3.3) Problématique à résoudre concernant le système

Pour la conception du système, je me suis posé les questions suivantes :

Quel capteur utilisé pour construire une balance de 0-20Kg avec 0,02Kg de

précision ?

Comment protéger le capteur en cas de surpoids ?

Comment réaliser la partie mécanique du système ?

Comment commander le buzzer pour créer un signal sonore ?

Quelle intensité du buzzer est adaptée à l’environnement du système (dB) ?

Quel afficheur faut-il utiliser ?

Comment communiquer avec le lecteur RFID ? quel protocole ?

Quel est le protocole monétaire à est utiliser ?


Quel microcontrôleur utilisé ?

Comment faire une alimentation de ±5V ?

Comment configurer le signal PWM ?

Comment configurer la communication UART ?

Comment configurer le convertisseur analogique numérique ADC ?

Comment configurer le bus de communication I2C ?

Comment gérer la date et l’heure ?

Comment stocker les valeurs de calibrage pour le protéger en cas de coupure de

courant ?

Comment permettre au personnel d’accéder au menu du système ?

Quel protocole utilisé pour pouvoir changer les paramètres du menu ?

Quel composant et quel choix technologique faut-il mettre en œuvre pour obtenir un

prix de revient de moins de 1000€ ?

3.4) Diagramme sagittal

Figure 4 : Diagramme sagittal

L1 : Informe l’utilisateur grâce à un afficheur ou un signal sonore.

L2 : Envoi les informations du badge vers le système

L3 : Envoi des informations du système vers le badge

L4 : Grandeur physique du poids des assiettes

L5 : information permettant de savoir si on peut recharger les assiettes ou quelle est l’erreur

qui vient de ce produire.

IV) Etude générale et technique

4.1) Etude de la partie mécanique.

Pour faire une balance avec une ou plusieurs jauge(s) de contrainte, il faut usiner une pièce

métallique sur laquelle seront collées la ou les jauge(s). Cette pièce métallique est très

importante pour le bon fonctionnement de la balance. C’est en partie grâce à elle que l’on

pourra déterminer le poids maximum et la précision de la balance. Par exemple une pièce

d’acier aura moins de précision qu’une pièce d’aluminium mais elle pourra supporter un poids

plus important. Pour la balance que je dois réaliser, la pièce utilisée sera de l’aluminium car le


cahier des charges demande une balance 20Kg avec 0,02Kg de précision. Les deux trous de

gauche du schema ci-dessous servent à fixer la pièce métallique sur son socle. Les trous du

milieu sont là pour fragiliser les pièces ce qui permettra d’avoir une meilleure contrainte. Si la

contrainte n’est pas assez grande on pourra percer le trou pour l’agrandir. Le trou de droite

sert à fixer le plateau sur lequel seront posées les assiettes. Voir schéma ci-dessous.

Figure 5 : Pièce d’aluminium pour les jauges.

Après avoir dessiné la pièce, monsieur MENARD a demandé un devis chez Concept Métal.

Le devis proposé pour les quatre pièces était de 520€ HT. Ces quatre pièces seront fixées sur

les angles du socle comme si dessous. Le plateau sera posé par dessus.

Figure 6 : Balance vue du haut

Jauge de contrainte

Balance vue du haut


4.2) Etude des jauges de contrainte

Une jauge de contrainte est un élément métallique collé sur la surface d’une pièce. Lorsque la

pièce est sollicitée, elle se déforme. La jauge subit alors la même déformation que la pièce.

Cette déformation modifie certaines caractéristiques physiques du matériau, notamment sa

résistance.

R = (ρxl)/s On peut montrer que : ΔR/R = Kx ε où ε = Δl/l voir datasheet en annexe.

La variation de la résistance d’une jauge de contrainte est proportionnelle à la déformation de

la jauge donc de la surface de la pièce sur laquelle elle est fixée. Depuis la déformation, on

peut remonter jusqu'à la contrainte dans la pièce et donc à l’effort qui lui est appliqué et vice

versa.

Le matériel le plus utilisé pour la fabrication de jauges est le constantan (cuivre et nickel). Ses

caractéristiques sont suivantes :

Sensibilité constante même pour de grandes déformations.

Résistivité élevée, donc grande résistance pour de petites longueurs, ce qui permet de

réaliser de très petites jauges.

Très stable et relativement peu affecté par les changements de température, ce qui est le plus grand problème rencontré dans la mesure de déformations avec des jauges.

Figure 7 : Photo de la jauge choisie

Effet thermique

Lorsqu’une jauge est collée sur un substrat

déterminé, elle subit des déformations suite à

la dilatation du matériau due aux effets

thermiques. C’est pourquoi les jauges

actuelles sont auto-compensées. Il faudra

donc choisir une jauge dont le coefficient de

dilatation est le plus proche de celui du

substrat sur lequel elle sera collée. Il faut

utiliser une colle EPOXY qui a la

caractéristique de suivre la contrainte.


Désensibilisation due à la longueur des câbles :

La mesure d’une jauge serait parfaite si les câbles de liaison étaient très courts mais le collage

d’une jauge sur une structure nécessite de grandes longueurs de câble. Ces câbles présentent

une résistance complémentaire R non négligeable.

Ainsi, au lieu de voir la résistance de la jauge Rj, le pont voit une résistance totale R’ égale à

la somme de Rj et R. Cependant, la variation de résistance due à la déformation, soit dR

n’affecte que Rj (R restant constante), ce qui à pour effet de désensibiliser la mesure.

Elongation maximale :

Toutes les jauges ont des limites d’allongement à ne pas dépasser sous peine de rompre la

grille. Pour les jauges choisies, les fabricants annoncent une élongation maximale de 2 à 4 %.

Attention : il faut aussi tenir compte du type de colle utilisée (voir effet thermique).

3.3) Etude de la partie communication avec le lecteur RFID

Figure 8 : Lecteur RFID utilisé

Les cartes MIFARE comportent une puce (chip) qui est reliée à un bobinage. Ce bobinage

permet d’alimenter la puce grâce à un effet d’induction (c’est le même principe que les

transformateurs) quand il est posé sur le lecteur.

Figure 9 : Carte MIFARE


Figure 10 : Protocole MIFARE

Pour m’aider à faire le programme de la balance, SYMOTRONIC m’a fourni un logiciel

permettant de communiquer avec le lecteur RFID. Ce programme permet d’envoyer des

trames RS232 au lecteur pour voir quels sont les octets reçus en fonction de la trame envoyée.

Voici un exemple de lecture du block 4 de carte RFID.

Figure 11 : Trames

Il faut donc envoyer six trames différentes pour lire un block

Le protocole MIFARE : Liste des six trames envoyées et octets reçus (hexadécimal).

-MIF Scan (connection)

E: 80.A0.03.00.01

R: A0.01.90.00

-MIF Read_UID (lecture numéro de carte)

E: 80.B0.01.00.04

R: B0.E3.09.FB.BD.90.00

-MIF loadkeya (chargement clés)

E: 80.D0.80.00.06

R: D0

E: FF.FF.FF.FF.FF.FF

R: 90.00

-MIF Open_Session (ouvrir session)

E: 80.A2.00.00.04

R: A2.90.00

-MIF Close_session (fermée session)

E: 80.E0.00.00.00

R: 90.00


-MIF Read_Block (lire le block 4)

E: 80.B2.00.04.10

R: XX.XX……XX.XX

Le protocole de payement: pour des raisons de confidentialité il m’a été interdit de divulguer

ces renseignements. je décrirai donc les grandes lignes et masquerai les informations

sensibles.

La Carte est séquencée en plusieurs blocks contenant des informations sur l’utilisateur et

autre. Il est important de connaitre la date et l’heure actuelles pour interagir avec la carte.

C’est pour cela qu’il faut utiliser une horloge temps réel.

CONCLUSION de l’étude générale et technique : Le prix de la fabrication des pièces pour la

balance étant trop cher pour le projet nous avons cherché une autre solution. N’existant pas

d’autre moyen que la contrainte pour fabriquer une balance avec une telle précision, nous

avons décidé avec monsieur MENARD d’acheter un plateau de balance avec jauge (208€ HT

au lieu de 520€ HT).

V) Développement technique 1ère

partie : Contexte technique

Figure 12 : Schéma fonctionnel

Voir développement technique 2

ème partie pour la description fonctionnelle des blocs

.

FA : Alimentation

Entrée

12V

Sortie

+5V et -5V

FS1 : Pont de Wheatstone.

Entrée

L4 : Grandeur physique du poids des assiettes


Sortie

Pw: Tension analogique des capteurs de pression non traitée (4 capteur de 20Kg max)

FS2 : Amplification & réglage du zéro.

Entrée

Pw : Tension analogique des capteurs de pression non traitée (4 capteur de 20Kg max)

Sortie

Capt 1 à 4 : Tension analogique des capteurs de pression interprétable par le microcontrôleur

(4 capteur de 20Kg max)

FS3 : Eeprom.

Entrée/ Sortie (Bus)

Sda : Bus de communication pour l’enregistrement dans une eeprom

Scl : Horloge

FS4 : Horloge temps réel.

Entrée/ Sortie (Bus)

Sda : Bus de communication pour l’horloge temps réel

Scl : Horloge

FS5 : microcontrôleur.

Entrée

Capt 1à4 : Tension analogique des capteurs de pression interprétable par le microcontrôleur (4

capteur de 20Kg max)

Sda/Scl : Bus de communication I2C avec horloge

Pgd/Pgc : Permet l’envoi du fichier HEX dans le microcontrôleur

Rx(TTL) : Réception des trames UART du protocole propriétaire de chez STID (w33CHP

iso7816)

Sortie

RC1 : Commande du buzzer

RD0à6 : Informations envoyées à l’afficheur.

Tx(TTL) : Envoi des trames UART du protocole propriétaire de chez STID

FS6 : ICD Programmation.

Entrée

L6 : Communication USB avec le PC pour l’envoi du fichier HEX.

Sortie

Pgd/Pgc : Sortie permettant l’envoi du fichier HEX dans le microcontrôleur.

FS7 : Gestion son.

Entrée


Sortie

L1 : Information sonore destinée à l’utilisateur.

FS8 : Afficheur.

Entrée

RD0à6 : Informations envoyées à l’afficheur.

Sortie

L1 : Information sonore destinée à l’utilisateur.


L5 : Information visuelle destinée à l’utilisateur.

FS9 : Conversion TTL/ RS232.

Entrée

Tx(TTL) : Envoi des trames UART du protocole propriétaire de chez STID

Rx(RS232) : Envoi des trames en norme RS232 du protocole propriétaire de chez STID

Sortie

Tx(RS232) : Envoi des trames en norme RS232 du protocole propriétaire de chez STID

Rx (TTL): Envoi des trames UART du protocole propriétaire de chez STID

FS10 : Lecteur RFID

Entrée

L3 : Communication avec les cartes MIFARE grâce à un effet d’induction

Rx(RS232) : Trames RS23S du protocole propriétaire de chez STID pour le lecteur RFID

Sortie

L2 : Communication avec les cartes MIFARE grâce à un effet d’induction

Tx(RS232) : Trames RS232 du protocole propriétaire de chez STID pour le lecteur RFID

CONCLUSION sur le développement technique 1er partie.

Pour que le système fonctionne correctement et réponde au mieux au cahier des charges, j’ai

besoin des 11 fonctions ci-dessus.


VI) Développement technique 2ème

partie : Etape de la

réalisation

Ne sachant pas encore que le prix des pièces à usiner serait aussi couteux, j’ai réalisé deux

schémas différents pendant mon stage. Ci-dessous le schéma utilisé pour le câblage du

prototype et en annexe le 1er schéma réalisé.

Figure 13 : 2

ème schéma réalisé (utilisé pour le prototype)


6.1) Liste des composants

55 Resistors

Quantity: References Value Prix HT €

2 R1, R46 10k 0.2

8

R2, R3, R14, R15, R26, R27, R38, R39 22k 0.8

20

R4, R9, R10, R12, R13, R16, R21, R22, R24, R25, R28, R33, R34, R36, R37, R40, R45, R48, R54, R55 1k 2

8

R5, R6, R17, R18, R29, R30, R41, R42 2.2k 0.8

8

R7, R8, R19, R20, R31, R32, R43, R44 68k 0.8

4 R11, R23, R35, R51 60 0.4

2 R47, R50 470 0.2

1 R49 10 0.1

2 R52, R53 4.7k 0.2

40 Capacitors

Quantity: References Value

5 C1-C4, C43 0.1uF 0.5

2 C5, C6 18pF 0.2

20

C7, C9, C10, C15-C21, C28, C29, C32-C39 100nF 2

2 C8, C27 100uF 0.2

9 C11-C14, C23-C26, C30 10uF 0.9

2 C22, C31 1nF 0.2

12 Integrated Circuits


1 U1 MAX232 1.2

1 U2 PIC18F4520 6.5

1 U3 7805 1

1 U4 7809 1

4 U5-U7, U12 TL084 34

1 U8 7905 1

1 U9 ICL7660 3

1 U10 DS1307 3.5

1 U11 24LC256 3.5


1 Transistors


1 Q13 2N2222 0.1

10 Diodes


4 D1-D4 1N749A 8

4 D5-D8 1N4148 0.5

2 D10, D12

0.5

35 Miscellaneous


1 BUZ1 BUZZER 1.5

9 J1, J3, J13, J18, J20, J27-J29, J39 CONN-H4 1

1 J2 ALIM +12V 0.1

1 J7 programmation 0.2

1 J8 quartz 0.2

1 J9 VBat 1.5

1 J10 CONN-H5 0.2

2 J11 CONN-SIL3 0.2

1 LCD1 LCD122 15

1 X1 CRYSTAL 0.2

4 Plateau balance JAUGE 832

1 Lecteur rfid RFID 76

TOTAL HT:

974€

Pour réaliser le schéma et le typon, j’ai

utilisé la suite Protéus avec des logiciels Isis

et Ares. Comme beaucoup des composants

utilisés n’avaient pas d’empreinte, je les ai

conçu moi-même.

Figure 14 : ARES


6.2) Alimentation linéaire

La fonction alimentation permet de créer, grâce à une tension d’entrée de 12V, du +9V, +5V,

0V et du -5V en sortie. L’alimentation 9V permet d’éviter de mettre un amplificateur rail to

rail qui aurait augmenté sensiblement le coût du dispositif.

Figure 15 : Alimentation

C8, C27 : Condensateurs chimiques polarisés. Ils réalisent le filtrage.

C9, C10 C28, C29, C20 : Condensateurs plastiques, servent d’antiparasite pour

supprimer les hautes fréquences (ils sont conseillés dans la documentation technique).

C30 : Condensateur chimique polarisé.

U3 : 7805 régulateur 5V il permet de réguler la tension d’entrée 9V DC en une tension de 5V DC. D’après la documentation constructeur du 78XX il faut une tension

d’entrée minimum de la tension de sortie plus Vdrop (2V), soit Ve = Vs + Vdrop = 5 +

2 = 7V minimum, pour un bon fonctionnement du régulateur.

U4 : 7809 régulateur 9V il permet de réguler la tension d’entrée 12V DC en une

tension de 9V DC.

U9 : ICL7660 inverseur de tension il permet d’inverser une tension 12V en -12V.

U8 : 7905 régulateur -5V il permet de réguler la tension d’entrée -12V DC en une tension de -5V DC.

R47, D10 : informe de l’état de l’alimentation.

Calcul d’un radiateur : Hypothèse : Isystéme = 200mA

Pmax(+ou-5V) = (Tj – Ta)/RTHja = (125-25)/65 = 1,5W

Putil(5V) = Isystéme*(Ve-Vs) = 200*10^-3*(12-5) = 1,4W |Putil(-5V)| = Isystéme*(Ve-Vs) = 200*10^-3*(-10+5) = 1W

Conclusion : Putil<Pmax, l’utilisation d’un radiateur pour les régulateurs n’est pas

indispensable à température ambiante.


6.3) Pont de Wheatstone avec jauge de contrainte

Cette fonction permet de fabriquer quatre capteurs de pression. Chaque pont comporte quatre

jauges de contrainte qui varient en fonction de la déformation des matériaux sur lequel est

posée la jauge. Un capteur à quatre jauges permet d'avoir une meilleure précision qu'un

capteur à une jauge. Le pont de Wheatstone est nécessaire pour pouvoir mesurer les variations

des résistances dues à leur trop faible variation.

Figure 16 : jauge de contrainte en pont

J : jauge de contrainte placée aux quatre extrémités de chaque plateau de la balance. Il est important qu’elles soient toutes reliées avec des fils de même longueur et torsadés.

6.4) Traitement du signal

La partie traitement du signal permet d’alimenter et d’amplifier la tension fournie par le pont

de Weatstone tout en minimisant le bruit. Cette fonction permet aussi de régler le 0Volt pour

calibrer la contrainte subie par le matériel au repos.

1ere

solution :

Figure 17 : Traitement de signal


R38, R39 : permet l’amplification du pont de Weatstone réglable de 5 à 10000 en

boucle fermée. Gain = 1 + R39/R38.

R40 à R43, POT 10K, D7 et D8 permet de régler le 0Volt pour calibrer la contrainte subie par le matériel au repos. Les 1N827 sont des diodes zener à compensation de

température. ADJ = ±6.2xR41/(R40+R41)

Q10 à Q12, R35 à R37 : cette structure forme un amplificateur de courant pour l’alimentation des jauges de contrainte.

U7 : Un amplificateur spécialement adapté est compatible avec les jauges de contrainte standard. Son avantage est :

-Grande vitesse

-Pas d'alimentation flottant nécessaire

-Absence d'effets de mode commun

-Une très grande stabilité

-Un Faible bruit

2ème

solution :

Après avoir reçu le plateau de la balance et avoir mesuré les variations de tension en sortie du

pont, j’ai décidé de refaire le schéma de la partie traitement du signal pour une meilleur

maîtrise des résultats.

Figure 18 : Traitement de signal

C32, C33 : ces deux condensateurs permettent de filtrer la sortie. Voire ci-dessous les deux relevés des oscillogrammes de sortie avec et sans condensateur.


Figure 19 : Sans condensateur

Figure 20 : Avec condensateur

U49, U50, R2 à R4 : Forme un amplificateur d’instrumentation. N’utilisant pas un amplificateur

d’instrumentation intégré j’ai choisi le OPA177 car il a

une dérivée d’offset de 0,3uV/C°

Gain = ((R3xR2+R4)/R4) = 45

Fonction de transfert = V49-V50 = (Vbleu-Vmarron) x

((R3xR2+R4)/R4)

U51, R5 à R8 : Amplificateur différentiel. Permet de multiplier la différence de potentiel entre V49 et V50.

Gain = R7 / R6 = 31

V51 = (V40 – V50)x(R7 / R6)

U5D ; R9 à R13 ; D1, D5, D9 : Amplificateur

différentiel. La tension V51 varie de

-0,98 à 4,3V. Cette amplificateur différentiel associé à

une diode zener permet de recentrer la tension sur 0,

+5,2V.

Gain = 1

V52 = (4.3 – V51)x(R12 / R13)

Figure 21 : Simulation,

réalisé avec d’autre valeur

Pour effectuer les tests j’ai utilisé, un AOP TL084 mais celui-ci avait une dérivée

d’offset sur 4°C de 100mV (amplifié) en sortie alors que l’AOP OPA177 a une

variation de 1,4mV.

On peut remarquer que même filtrée la tension de sortie (Figure 20) n’est pas

totalement droite. Même si les piques de tension sont trop petits pour être interprétés

par le convertisseur A-N (résolution de 5mv) j’ai choisi de faire pour l’acquisition du

signal une moyenne sur 50 point d’acquisition.


Tension en fonction du poids :

Le graphique ci-dessous illustre la tension de sortie en fonction du poids. On remarque qu’elle

est totalement linéaire on pourra conter facilement les assiettes grâce à la relation suivante :

Nombres d’assiette = Vud / calibrage.

Exemple : si Vud = 1,32v = 264bits pour le ADC et que calibrage = 0,235v = 47bits on a :

Nombres d’assiette = 264/47 = 5 assiettes sur notre plateau.

Figure 22 : Droite de Vud en fonction du poids (0-10Kg ; 0-5V)

6.5) Eeprom & Horloge temps réel

Cette fonction assure grâce à un bus I2C la communication entre le microcontrôleur, l’eeprom

et l’horloge temps réel.

Figure 23 : EEPROM & horloge temps réel

U10 : Le DS1307 est une horloge temps réel (Real Time Clock), qui fournit secondes,

minutes, heures, jours, dates, mois et années grâce à un bus I2C.

0

2

4

6

8

10

12

0,029 1,3 2,565 3,79 5,02

Série1


U11 : Le 24LC256 est une PROM effaçable électriquement (EEPROM), capable de

travailler avec une large gamme d’alimentation 1,8 à 5,5V grâce à un bus I2C.

C43 : Le condensateur plastique sert d’antiparasite pour supprimer les hautes fréquences

Quartz : horlogerie de fréquence nominale 32,768 kHz

J9 : Pile de sauvegarde, au lithium 3 V / 48 mAh, la date et l'heure sont conservées pendant plus de 10 ans en l'absence d’alimentation principale

6.6) Afficheur

Il permet l’affichage sous forme digitale des informations à destination de l’utilisateur.

L’écran choisi est un LCD 2x24 avec rétro éclairage. L’empreinte de ce composant n’existant

pas sur Ares, j’ai du la créer.

Figure 24 : LCD

Description des broches de l’afficheur LCD

7 à 14 : D0 à D7 : Bus de données. Dans notre cas le bus est sur 4 bits de D4 à D7

6 : E : Entrée de validation (ENABLE); elle est active sur front descendant. Lorsque

E=0 les entrées du bus de l'afficheur sont à l'état haute impédance.

5 : R/W: Lecture ou écriture. (READ/WRITE). Lorsque R/W est au niveau bas, l'afficheur est en mode "écriture", et lorsque R/W est au niveau haut, l'afficheur est en

mode "lecture".

4 : RS: Sélection du registre. (REGISTER SELECT). Grâce à cette broche, l'afficheur est capable de faire la différence entre une commande et une donnée. Un niveau bas

indique une commande et un niveau haut indique une donnée.

3 : VLC : Cette tension permet le réglage du contraste de l'afficheur.

2 : VCC : +5V

1 : GND : Masse.


6.7) Microcontrôleur

Il assure grâce à un traitement programmé (logiciel microcontrôleur), l’acquisition, le traitement

et la restitution des informations. J’ai choisi ce microcontrôleur car il possède une mémoire de

programme de 32Koctets, une mémoire de donnée de 256 octets, de nombreux ports

d’entrées/sorties, 13 ADC sur 10bits pour la conversion analogique des jauges de contrainte et

une communication UART pour le dialogue avec le lecteur RFID. Il possède également un

bus I2C pour la communication avec une eeprom externe et une horloge temps réel.

Figure 25 : Microcontrôleur

J20 à 23 : permet de connecter la sortie du traitement du signal au microcontrôleur. Ne connaissant pas encore exactement la sortie, ces quatre Switch sont là pour permettre

l’adaptation du signal sur une autre carte avant d’être renvoyé au microcontrôleur si

besoin.

C7 : Condensateur plastique, sert d’antiparasite pour supprimer les hautes fréquences.

X1, C5, C6 : structure de quartz et condensateurs permettant de créer une horloge pour le microcontrôleur.

R52, R53 : Resistance de pull-up pour le bus I2C

U2 : Le PIC18F4520 est une architecture étendue basée sur la famille des PIC18F452 il offre de nouvelles fonctionnalités comme : un jeu d'instructions étendues, des modes

de gestion de l'alimentation, une vitesse plus élevée au niveau du ADC, l’USART a

été renforcé et bien d’autres nouveautés.


Définition des entrées, sorties du microcontrôleur

Entrées :

AN0 à AN3 : Entrées analogiques avec une résolution 10bits, elle permet de convertir la

tension analogique fournie par l’amplificateur de jauge en signal numérique interprétable par

le microcontrôleur.

RX : Permet la réception des trames UART pour la communication avec le lecteur de carte

RFID.

SDA : Permet la communication avec l’eeprom et l’horloge temps réel grâce à un bus I2C

OSC1, OSC2 : Entrées d’horloge reliée à l’oscillateur à quartz

MCLR : Entrée permettant la remise à zéro du microcontrôleur.

PGD : Broche permettant la programmation du microcontrôleur.

PGC : Broche permettant la programmation du microcontrôleur.

Sorties :


RC2 : Commande de la LED D12 pour la maintenance RD0 à RD6 : Commande permettant la communication avec le LCD

SDA : Permet la communication avec l’eeprom et l’horloge temps réel grâce à un bus I2C

SCL : Horloge pour le bus I2C

TX : Permet la transmission des trames UART pour la communication avec le lecteur de carte

RFID.

6.8) Buzzer

La fonction buzzer permet d’informer l’utilisateur grâce à un signal sonore.

Figure 26 : Buzzer

R46 : Resistance de 100K pour assurer un facteur de saturation du transistor de 10.

Q13 : Transistor NPN fonctionnant en commutation pour commander le buzzer.

BUZ1 : le buzzer crée un signal sonore pour avertir l’utilisateur en cas de problème.

6.9) Programmation

Cette fonction permettant la connexion d’un ICD pour la programmation du microcontrôleur.


Figure 27 : Programmation

J7 : permet la connexion et l’envoi du fichier HEX à programmer dans le microcontrôleur.

R1 : permet de fixer un potentiel de 5v sur MCRL pour empêcher le reset du microcontrôleur.

6.10) Communication RS232

Cette fonction permet de réaliser la liaison RS232 vers des circuits TTL. Il génère les tensions

nécessaires à la norme RS232 de l'ordre +10V/-10V à partir de 5V en utilisant uniquement

des condensateurs externes.

Figure 28 : MAX232

U1 : Le max 232 est un circuit permettant de faire une conversion bipolaire des signaux TTL et RS232.

C1, C3 : servent de doubleur de tension

C2, C4 : servent d’inverseur de tension


6.11) Typon

Tous les typons ont été faits à la main.

Top copper :

Figure 29 : Typon top copper

Bottom copper :

Figure 30,31 : Typon bottom copper

6.12) Vue 3D du future prototype

Figure 32 : Typon 3D

Après avoir fini le typon, nous avons fait

faire un devis avec un collègue

technicien chez J3T et PCB électronique

pour connaitre le prix d’une carte. J3T

nous a proposé un devis de 450€ pour la

carte. Le prix étant trop élevé pour le

coût de revient du prototype. J’ai réalisé

un typon plus petit sans la partie

traitement du signal.

La carte de prototype sera donc en trois parties :

-pont de Weatstone

-traitement du signal

-le reste (microcontrôleur, eeprom, RS232, horloge temps réel, affichage…)


Figure 33 : Typon en simple face

Finalement après avoir tout testé et câblé j’ai réalisé, un troisième typon en double face pour

faire tirer la carte en grande série. PCB électronique nous a adressé un devis de 234,85€ HT

pour 5 cartes.

Figure 34 : Typon final double face top copper et bottom copper

6.13) Programmation

J’ai réalisé la partie programmation

grâce au logiciel gratuit MPLAB

fourni par MICROCHIP. Ce

logiciel est un outil de

développement permettant de

programmer des microcontrôleurs

de type PIC en langage C ou en

assembleur.

Figure 35 : MPLAB


Figure 36 : ICD2

J’ai utilisé avec le logiciel MPLAB le programmateur

MPLAB ICD2 qui permet d’envoyer le fichier compilé

(.HEX) dans le microcontrôleur.

Apres avoir créé un nouveau projet avec MPLAB et avant de commencer à programmer, j’ai

adapté ou créé toutes les bibliothèques à inclure (pour le PIC18F4520) dont j’avais besoin

pour réaliser le programme.

p18f4520.h

main.h

lcd.h

usart.h

ADC.h

i2c.h

i2c2.h

delay.h

ds1307.h

eeprom24lc.h

Une fois les fichiers inclus et la compilation faite sans erreur, j’ai réalisé les algorithmes du

programme.

Figure 37 : Algorithme et description du programme principal (main)


J’ai créé l’algorithme du programme principal de manière à prendre en compte un maximum

d’erreurs que l’utilisateur peut faire de manière consciente ou inconsciente. Exemple des

contrôles pris en compte:

- Cohérence du badge

- Contrainte sur la balance

- Prise d’assiette sans crédit ou sans carte

- Carte non formatée

- Compteur max différent de 0 et inferieur à 56

- Compteur > compteur max

- Code site faux

- Date erronée

- Détection d’une ou plusieurs assiettes

- …

L’algorithme principal comporte aussi une machine à 2 états qui permet d’accéder au menu

du système. Celui-ci comporte une machine à quatre états (réglage de l’heure, réglage code

site, recharge assiette, calibrage).

Exemple de fonction réalisée :

La fonction ci-dessous permet l’ouverture de la session de la carte MIFARE grâce à la

communication UART

void MIF_Open_Session(void)

{

USARTWriteByte(0x80);

USARTWriteByte(0xA2);




while(USARTReadByte()!=0xA2);

for(Badge.inc=1;Badge.inc<5;Badge.inc++)

{USARTWriteByte(Badge.NumKey[Badge.inc]);}

while(USARTReadByte()!=0x00);

}

Figure 38 : Algorithme

La fonction ci-dessous permet l’acquisition de l’heure et de la date grâce à un bus I2C



void acq_horloge(void)

{

Horloge.sec = lire_ds1307(0x00);

Horloge.min = lire_ds1307(0x01);

Horloge.heu = lire_ds1307(0x02);

Horloge.jour = lire_ds1307(0x03);

Horloge.date = lire_ds1307(0x04);

Horloge.mois = lire_ds1307(0x05);

Horloge.annee = lire_ds1307(0x06);

if((Horloge.heu==0x23)&&(Horloge.min==0x59)&&(Horloge.sec>

0x50))

{

Horloge.date_hier = lire_ds1307(0x04);

Horloge.mois_hier = lire_ds1307(0x05);

Horloge.annee_hier = lire_ds1307(0x06);

}

}

La première fonction ci-dessous tourne en boucle tant que l’on détecte le badge. Elle fait

sonner le buzzer une fois pour signaler à l’utilisateur qu’il peut retirer sa carte du lecteur. La

deuxième fonction est identique mais elle fait biper le buzzer tant que l’utilisateur ne retire

pas sa carte. Elle est appelée en cas de problème. Exemples : mauvais badge, code site faux,

etc.

void Attente(void)

{

PORTCbits.RC1 = 1;

DelayMs(80);

PORTCbits.RC1 = 0;

do{affichage_H_date();

MIF_Scan();

Lire_RFID();

}while(Badge.ok==vrai);

}

void Attente_erreur(void)

{

do{affichage_H_date();

PORTCbits.RC1 = 1;

DelayMs(150);

PORTCbits.RC1 = 0;

MIF_Scan();

Lire_RFID();


}

Figure 40: Algorithme

La fonction ci-dessous permet d’envoyer les valeurs de l’horloge grâce à un bus I2C aux

adresses indiquées dans la datasheet de l’horloge temps réel. void Chargement_horloge(void)

{

ecrire_ds1307(0x07,0b00010000);

ecrire_ds1307(0x00,Horloge.sec);

ecrire_ds1307(0x01,Horloge.min);

ecrire_ds1307(0x02,Horloge.heu);

ecrire_ds1307(0x03,Horloge.jour);

ecrire_ds1307(0x04,Horloge.date);

ecrire_ds1307(0x05,Horloge.mois);

Figure 41 : Tableau de commande


ecrire_ds1307(0x06,Horloge.annee);

}

La fonction affichage_H_date permet de récupérer la date et l’heure stockées dans l’horloge

temps réel en hexadécimal puis de la convertir en DCB et de l’afficher.

void affichage_H_date(void)

{

UC8 txt29[2] = ":";

UC8 txt30[2] = "/";

UC8 txt31[2] = " ";

UC8 conversion_DCB=0;

acq_horloge();

LCDLine1();

conversion_DCB = Horloge.heu/16;

Bin2BCD(conversion_DCB);

LCDwrite(Least_Sig_Byte);

conversion_DCB = Horloge.heu%16;



text_display(txt29);

conversion_DCB = Horloge.min/16;



conversion_DCB = Horloge.min%16;




conversion_DCB = Horloge.date/16;



conversion_DCB = Horloge.date%16;




conversion_DCB = Horloge.mois/16;



conversion_DCB = Horloge.mois%16;




conversion_DCB = Horloge.annee/16;



conversion_DCB = Horloge.annee%16;



DelayMs(50);

}


La fonction ci-dessous permet de récupérer et de stocker les informations d’un block dans un

tableau. Cette fonction est importante car on ne peut pas écrire qu’un seul octet dans un bloc il

faut réécrire tout le bloc. On récupère donc le bloc, on change les octets que l’on veut et on

renvoie le bloc.


void Lire_RFID_BLOCK(void)

{

Badge.pas_bon=0;

if(USARTReadByte()==0xB2)

{


{

Badge.acquisition_donnee[Badge.inc] =

USARTReadByte();

}


}else

{

USARTReadByte();

Badge.pas_bon=1;}}




La fonction protocole_monetaire

permet d’écrire les informations

importantes pour le paiement dans

les blocks de la carte MIFARE

concernée (voir protocole pour

connaitre les blocks). L’algorithme

n’est pas accompagné du programme

car ces informations sont

confidentielles.

La première partie permet de trouver

le bon bloc. La deuxième permet de

trouver quels octets doivent être

remplacés dans le bloc. On peut aussi

remarquer que la fonction tourne en

boucle tant que l’on ne dépasse pas

Badge.total[0]. Le tableau

Badge.total contient la valeur du

nombre d’assiette(s) pris par

l’utilisateur. Exemples : si

l’utilisateur prend cinq assiettes,

alors on exécutera le protocole de

paiement cinq fois.

CONCLUSION sur le

développement technique 2ème

partie : La conception de cette partie

a été très intéressante car en plus de

mettre en œuvre de nombreuses

connaissances vues en cours, j’ai été

entrepris des recherches pour savoir

comment réaliser une balance,

comment fonctionne le bus I2C,

éviter les dérivés d’offset, etc. J’ai

donc acquis de nouvelles

connaissances. J’ai également

constaté que le coût de fabrication

d’une carte électronique est

important dans le prix de revient

d’un prototype. Cela est du aux

pertes importantes de matière

première pour la conception d’une

seule unité. C’est pourquoi il n’y a

que 10 euros de différence entre une

et cinq carte(s). Il faut compter 450€

pour faire une carte et 460€ pour 5

cartes.


VII) Développement technique 3ème partie : Tests / suivi /

évolution

Figure 45 : Câblage du prototype

Figure 46 : Câblage du prototype zoom

- Microcontrôleur - LCD 2x24 - Buzzer - Contraste - Horloge temps réel - Lecteur RFID - Badge MIFARE

-assiettes (0,4Kg) -Plateau de la balance

-Amplification et réglage du

zéro


Après avoir câblé le maximum d’éléments du système sur une platine, j’ai testé le programme

pour voir s’il était conforme au cahier des charges. J’ai également « snifé » les trames

envoyées et reçues grâce à un logiciel que SYMOTRONIC m’a fourni. Cela m’a permis de

remarquer que certains octets communiquaient en même temps. Même si cela ne posait pas de

problème dans la pratique, j’ai modifié le programme pour que le dialogue se déroule sans

qu’il y ait d’envoi et de réception en même temps par les deux systèmes communiquants.

Figure 47 : Ecran principal (affichage de l’horloge temps réel et attente d’un badge)

Vérification des trames envoyées et reçues :

Carte ok mais pas d’assiette prise :

Figure 48 : Détection badge

Carte ok avec prise d’assiette :

Une fois l’assiette prise, incrémentation du compteur puis suite du protocole dans les

différents blocs concernés.

- Détection de la carte MIFAR

- Block contenant les informations utilisateur et le protocole de paiement

Incrémentation du compteur après la

prise d’assiette.


Mauvaise carte :

La détection d’une mauvaise carte se fait quand l’on détecte une erreur dans le protocole.

Figure 49 : Détection d’un mauvais badge

Réglage de l’heure :

Le réglage de l’heure et de la date se fait grâce à un badge prévu à cet effet. Un protocole a

été établi spécifiquement pour accéder au menu du système.

Figure 50 : Réglage de l’heure

Recharge d’assiette(s)

La recharge d’assiette est possible grâce au badge qui permet d’accéder au menu. Cette partie

permet de recharger les assiettes et d’afficher leur nombre sur l’écran LCD. Voir photo ci-

dessous.

Erreur dans le protocole


Ci-dessous est présenté le plateau de la balance avec les jauges de contrainte

Figure 51 : Le plateau de la balance

Sachant qu’il faut compter 520€ pour réaliser les quatre pièces d’aluminium nous

avons décidé d’acheter un plateau déjà tout fait. Pour ce faire j’ai été en contact avec deux

entreprises, Bizerba et Kern. La première nous a proposé des plateaux avec une sortie

analogique entre 0 et 5V proportionnelle au poids pour 1000€ le plateau. Soit 4x1000=4000€

pour les plateaux d’un système. Kern nous a proposé des plateaux sans traitement pour 208€

soit 832€ pour un système. Le devis de Kern étant plus adapté à notre budget, nous avons

choisi d’acheter un plateau chez ce constructeur.

Ce plateau comporte en sortie la tension analogique du pont de Wheatstone qui est

directement relié à la carte électronique. La tension est ensuite traitée pour donner une droite

entre 0 et 5V proportionnelle au poids puis relié au convertisseur ADC du microcontrôleur. La

conversion analogique permet au programme de compter les assiettes grâce au code réalisé.

Une fois que l’on détecte le nombre d’assiettes prises sur le plateau, on va aller l’écrire sur la

carte grâce à la communication UART. Pour vérifier que l’écriture s’est bien déroulée avec

les bons octets aux bons endroits, j’ai utilisé le même appareil que SYMOTRONIC m’a prêté

en début de stage pour lire les informations. Après avoir remarqué quelques erreurs j’ai,

modifié mon code et refait les tests jusqu’au respect du cahier des charges.

- Les jauges collées sur les pièces

d’aluminiums.

- Le pont de Wheatstone

- Fil d’alimentation


VIII) CONCLUSION TECHNIQUE :

A la date de remise de mon rapport, j’ai pu tester la quasi totalité du système. L’accès au

menu fonctionne correctement. J’ai pu changer le code site, la date et l’heure, la recharge des

assiettes et faire le calibrage du système. J’ai également testé la prise d’assiette et l’écriture du

protocole dans la carte en fonctionnement nominal. Il me reste encore à faire l’écriture et la

lecture dans l’eeprom en cas de coupure de courant. Je devrais recevoir le typon le 22 juin. Il

me restera à assembler le prototype avant de l’installer sur site le 24 juin. La réussite de mon

projet se détermine par une conformité au cahier des charges et des tests exhaustifs de la

partie hardware. Le software pourra subir de légères modifications.

La réalisation de ce système m’a permis de passer en revue toutes les phases d’un projet

en commençant par l’établissement du cahier des charges, l’étude, la réalisation jusqu’aux

tests. J’ai étudié des protocoles de communication, des lecteurs RFID, les logiciels. J’ai faire

preuve d’autonomie, d’initiative, d’esprit critique et d’organisation afin d’être le plus efficace

possible pour achever mon travail avec succès.

Grâce à ce stage, j’ai amélioré mes connaissances en électronique et en programmation.

J’ai acquis des connaissances dans la communication I2C et dans le domaine des

amplificateurs opérationnels ainsi que dans les méthodes utilisées pour la fabrication de

système de précision, jauge de contrainte et pont de Wheatstone.

IX) CONCLUSION GENERALE :

Ces dix semaines de stage passé chez SYMOTRONIC m’ont apporté beaucoup plus que

des connaissances techniques. Depuis mon BEP d’électronique, je n’avais jamais eu

l’occasion de mettre à profit mes connaissances dans le monde professionnel. Ce stage m’a

conforté sur le dans le choix du domaine professionnel que j’ai fait six ans en arrière. A

l’issu de ce premier cycle d’études supérieures je souhaite plus que jamais poursuivre mes

études en école d’ingénieur en électronique.

J’ai également remarqué qu’avoir de bonnes connaissances techniques n’est pas suffisant

pour la réalisation d’un projet et qu’il faut savoir faire preuve de polyvalence : Discussion

avec le client, appel d’offre et négociation des prix avec les fournisseurs et rédaction de

documents. Cette expérience m’a amenée à considérer l’importance des échanges relationnels.

J’ai eu l’opportunité de faire mon stage dans une petite entreprise. Cela m’a permis de

voir quel poste chaque personne occupait et en quoi chacun était important pour le bon

fonctionnement de l’entreprise.

Pour finir, je retiens que pour envisager une carrière dans le métier qui me passionne, je

ne devrai m’investir dans mon travail, accepter les déplacements voire les missions à

l’étranger, m’amélioré dans l’écriture des dossiers et la pratique de l’anglais. J’ai constaté que

la qualité de l’enseignement de l’IUT m’a permis de m’adapter rapidement au milieu

professionnel et à différentes méthodes de travail.


Sommaire des annexes

1

er schéma réalisé …………… 43

Datasheet: LCD …………… 44

Datasheet: EEPRPM …………… 45

Datasheet: PIC18F4520 …………… 47

Datasheet : Horloge temps réel …………… 47

Datasheet : Jauge de contrainte …………… 48

Datasheet : Buzzer …………… 51

Devis PCB …………… 52

Datasheet : Inverseur de tension …………… 53

Datasheet : MAX232 …………… 54

Le programme intégral …………… 55


1er schéma réalisé


Datasheet : LCD


Datasheet : EEPROM



Datasheet : PIC18F4520

Datasheet : Horloge temps réel


Datasheet : Jauge de contrainte




Datasheet : Buzzer


Devis PCB


Datasheet : Inverseur de tension


Datasheet : MAX232


Le programme intégral : ne contient pas les includes.

/*********************************************************************

Configuration du micro

OSC = oscillateur

WDT = watchdog

*********************************************************************/

#pragma config OSC = HS

#pragma config WDT = OFF

/*********************************************************************

Bibliothèque

*********************************************************************/

#include <p18f4520.h>

#include <main.h>

#include <lcd.h>

#include <usart.h>

#include <07 ADC.h>

#include <i2c.h>

#include <i2c2.h>

#include <delay.h>

#include <ds1307.h>

#include <eeprom24lc.h>

/*********************************************************************

Definition type

*********************************************************************/

typedef unsigned char UC8;

typedef char C8;

typedef unsigned int UI16;

typedef int I16;

typedef unsigned float UF16;

typedef float F16;

/*********************************************************************

Definition

*********************************************************************/

#define vrai 1

#define faux 0

#define UID_recharge2 0xFF

#define UID_recharge1 0xFF

#define vert 0

#define rouge 1

#define sel_num 0x01

/*********************************************************************

Fonction

*********************************************************************/

void temps4s(void);

void InterruptHandlerHigh(void);

void Config_d_interuption(void);

void Acquisition_CAN(void);

void Initialisation_structure(void);

void MIF_Scan(void);

void MIF_Read_UID(void);

void MIF_loadkeya(void);

void MIF_Open_Session(void);

void MIF_Close_session(void);

UC8 MIF_Read_Block(UC8 block);

void MIF_Write_Block(UC8 block);


void Lire_RFID(void);

void utilisateur(void);

void Lire_RFID_BLOCK(void);

void Bin2BCD (unsigned char);

void Affiche_ID(void);

void Affiche_recharge(void);

void acq_horloge(void);

void affichage_H_date(void);

void Attente(void);

void Attente_erreur(void);

void servez_vous(void);

void Chargement_horloge(void);

void Menu_systeme(void);

void assiette_actu(void);

void assiette_prec(void);

void PCD_output(UC8 couleur);

void protocole_monaitaire(void);

void Lire_RFID_autre_BLOCK(void);

void MIF_Write_autre_Block(UC8 block);

void calibrage(void);

void affichage_nbautilisateur(void);

/*********************************************************************

Structure

*********************************************************************/

struct capteur

{

UI16 capt1;

UI16 capt2;

UI16 capt3;

UI16 capt4;

UC8 choix;

UC8 erreur;

UC8 assiette1;

UC8 assiette1_pr;

I16 pourcent_erreur[2];

UI16 calibre[3];

UI16 moyenne[50];

UC8 diviseur_lin;

};

struct RFID

{

UC8 acquisition_donnee[20];

UC8 acquisition_autre_donnee[20];

UC8 inc;

UC8 type;

UC8 prestation;

UC8 total[2];

UC8 ok;

UC8 NumKey[5];

UC8 nb_possibe;

UC8 num_caisse;

UC8 code_site[2];

UC8 erreur;

UC8 pas_bon;

UC8 desk_num;

UC8 transaction;

UC8 block_monais;

};


struct Temps

{

UC8 heu;

UC8 min;

UC8 sec;

UC8 jour;

UC8 date;

UC8 date_hier;

UC8 mois;

UC8 mois_hier;

UC8 annee;

UC8 annee_hier;

};

/*********************************************************************

Variable global

*********************************************************************/

struct capteur Gestion;

struct RFID Badge;

struct Temps Horloge;

unsigned char Most_Sig_Byte,Middle_Sig_Byte,Least_Sig_Byte;

UC8 effL2[25] = " ";

/*********************************************************************

programme principal

*********************************************************************/

#pragma code

void main()

{

UC8 txt1[10] = " Bonjour,";

UC8 txt18[23] = "mauvais badge ";

UC8 txt19[23] = "Enlever le badge ";

UC8 txt15[23] = "reposez assiette(s) ";

UC8 txt14[21] = " Erreur de badge: ";

UC8 pre[14] = "prechauffage:";

UC8 boucle=0;

UC8 i=10;

TRISA = 0b11111111;

PORTA = 0b00000000;

TRISC = 0b10011000; // portc en sortie =0, entrée=1

PORTC = 0b00000000; // portc = 0

Initialisation_structure(); // initialisation des diff variables

LCDInit(); // initialisation LCD

DisplayClr(); // effacer le LCD

USARTInit(); // initialisation UART

ADC_Init(); // initialisation ADC

//Acquisition_CAN(); // acquisition des 4 ports analogique

i2c_init(); // init i2c

Chargement_horloge();

affichage_H_date();

text_display(txt1);

PCD_output(vert);

for(i=10;i>0;i--)

{LCDLine2();

text_display(pre);


Bin2BCD(i);

LCDwrite(Most_Sig_Byte);

LCDwrite(Middle_Sig_Byte);


DelaySec(1);

}

while(1)

{

do{

if(Badge.pas_bon==1)

// =1 mavais badge

{MIF_Close_session();

LCDLine2();


Attente_erreur();

DelayMs(50);

Badge.pas_bon=faux;

}else{

// le badge et Ok

utilisateur();

assiette_prec();}

do{

// attente d'un badge + verification prise d'assiette

assiette_actu();

if(Gestion.assiette1>Gestion.assiette1_pr)

{

PORTCbits.RC1 = 1;

DelayMs(50);}

else

{PORTCbits.RC1 = 0;}

if((Gestion.assiette1<Gestion.assiette1_pr))

{LCDLine2();


PORTCbits.RC1 = 1;}

else

{PORTCbits.RC1 = 0;utilisateur();}

affichage_H_date();

MIF_Scan();

//fonction d'autentification lecteur RFID

Lire_RFID(); //lire

les informations envoyé par le lecteur RFID

}while(Badge.ok==faux);

Badge.ok==vrai;

MIF_Read_UID(); //fonction

lecteur RFID

MIF_loadkeya(); //fonction

chargement de la clé A

MIF_Close_session();

MIF_Open_Session();

MIF_Read_Block(4);

Lire_RFID_BLOCK();

}while(Badge.pas_bon==1);

if((Badge.acquisition_donnee[1]==UID_recharge1)&&(Badge.acquisition_donnee[2]==UID_recharge2

)) //si octets 1&2 =0xFF alors carte de réglage

{

Menu_systeme();


Attente();

Acquisition_CAN();

}

else

{

MIF_Close_session(); //fonction de fermeture de la session

MIF_Open_Session(); //fonction d'ouverture de la session

MIF_Read_Block(4); //fonction lecture du block

Lire_RFID_BLOCK(); //lire les informations envoyé par le

lecteur RFID

LCDLine2();

if((Badge.acquisition_donnee[16]==0xFC)&&(Badge.acquisition_donnee[2]>0)) // badge formaté ok

{

if((Badge.acquisition_donnee[6]==Badge.code_site[0])&&(Badge.acquisition_donnee[7]==Badge.code

_site[1])) // code site ok

{

if((Badge.acquisition_donnee[1])<(Badge.acquisition_donnee[2])) //compteur < compteur max

{

if(((Horloge.date_hier==Badge.acquisition_donnee[3])&&(Horloge.mois_hier==Badge.acquisition_don

nee[4])&&(Horloge.annee_hier==Badge.acquisition_donnee[5]))||((Horloge.date==Badge.acquisition_donnee[3

])&&(Horloge.mois==Badge.acquisition_donnee[4])&&(Horloge.annee==Badge.acquisition_donnee[5])))//date

à J-1

{

servez_vous();

assiette_prec();

do{ affichage_H_date();

if(Gestion.assiette1>Gestion.assiette1_pr)//bip si appuis sur la balance

{

PORTCbits.RC1 = 1;

}

else{

PORTCbits.RC1 = 0;

}

MIF_Scan();

//fonction d'autentification lecteur RFID

Lire_RFID();

assiette_actu();

if((Gestion.assiette1<Gestion.assiette1_pr)||(Badge.ok==faux))

{boucle=0;}else{boucle=1;}

}while(boucle==1);

DelaySec(2);assiette_actu();

if(Gestion.assiette1<Gestion.assiette1_pr)

{

MIF_Close_session();

//fonction de fermeture de la session

MIF_Open_Session();

//fonction d'ouverture de la session

MIF_Read_Block(4);

//fonction lecture du block


Lire_RFID_BLOCK();

//lire les informations envoyé par le lecteur RFID

Badge.total[0] =

(Gestion.assiette1_pr - Gestion.assiette1);

affichage_nbautilisateur();

Badge.acquisition_donnee[1] =

(Badge.acquisition_donnee[1]+ Badge.total[0]);

MIF_Write_Block(4);

Badge.acquisition_donnee[1] =

(Badge.acquisition_donnee[1]-Badge.total[0]);

protocole_monaitaire();

DelaySec(2);

}

LCDLine2();


Attente();

}else

{


Bin2BCD(4);


Attente_erreur(); }

}else

{


Bin2BCD(3);


Attente_erreur();

}

}else

{


Bin2BCD(2);


Attente_erreur();}

}else

{


Bin2BCD(1);


Attente_erreur();

}

}

}

}

/*********************************************************************

Fonction permettant d'écrire dans les bons blocks (voire protocole

AGAPES application 20090311)

*********************************************************************/

void protocole_monaitaire(void)

{

UC8 sortie,i=0;

do

{i++;

sortie=0;

Badge.inc=0;

Badge.block_monais=5;

Badge.acquisition_donnee[1]++;


do{

if((Badge.acquisition_donnee[1]>=(1+Badge.inc))&&(Badge.acquisition_donnee[1]<=(4+Badge.inc)))

{

sortie=vrai;

}

else

{

Badge.block_monais++;

if((Badge.block_monais==7)||(Badge.block_monais==11)||(Badge.block_monais==15)||(Badge.block_

monais==19))

{Badge.block_monais++;}

Badge.inc=Badge.inc+4;

}

}while(sortie==faux); // permet de trouver le bon block

if(Badge.acquisition_donnee[1]!=0)

{

Badge.transaction = Badge.acquisition_donnee[1]%4;

if(Badge.transaction==0)

{Badge.transaction = 4;}

}

else

{

Badge.transaction = 1;

}

Badge.transaction = (Badge.transaction*4)-4; //permet de trouver la transaction

MIF_Read_Block(Badge.block_monais); //fonction lecture du block

Lire_RFID_autre_BLOCK();

Badge.acquisition_autre_donnee[Badge.transaction+1]=Horloge.heu;

Badge.acquisition_autre_donnee[Badge.transaction+2]=Horloge.min;

Badge.acquisition_autre_donnee[Badge.transaction+3]=Badge.desk_num;

Badge.acquisition_autre_donnee[Badge.transaction+4]=sel_num;

MIF_Write_autre_Block(Badge.block_monais);

if(i<Badge.total[0])

{Badge.total[1]=vrai;}

else{

Badge.total[1]=faux;}

}while(Badge.total[1]==vrai); // tourne en boucle autant de fois que le nombre d'assiette

Badge.total[0]=0;

}

/*********************************************************************

Menu du système (voire protocole pour les réglages)

*********************************************************************/

void Menu_systeme(void)

{

UC8 txtC[23] = "chargement des donnees";

switch(Badge.acquisition_donnee[14])

{

case 1: LCDLine2();

text_display(txtC);

MIF_Read_Block(5);

Lire_RFID_BLOCK();

Badge.num_caisse=Badge.acquisition_donnee[1];

Badge.code_site[0]=Badge.acquisition_donnee[8];

Badge.code_site[1]=Badge.acquisition_donnee[9];


break;

case 2: LCDLine2();

text_display(txtC);

MIF_Read_Block(5);

Lire_RFID_BLOCK();

Horloge.min = Badge.acquisition_donnee[6];

Horloge.heu = Badge.acquisition_donnee[5];

Horloge.jour = Badge.acquisition_donnee[1];

Horloge.date = Badge.acquisition_donnee[2];

Horloge.mois = Badge.acquisition_donnee[3];

Horloge.annee = Badge.acquisition_donnee[4];

Chargement_horloge();

break;

case 3: Affiche_recharge();

break;

case 4: calibrage();

break;

case 5: LCDLine2();

text_display(txtC);

MIF_Read_Block(5);

Lire_RFID_BLOCK();

Gestion.diviseur_lin=Badge.acquisition_donnee[1];

break;

default:;

}

}

void calibrage(void)

{

UC8 i;

UC8 txt13[23] = "Poser une assiette ";

Gestion.capt1=0;

for(i=0;i<50;i++){

Gestion.moyenne[i] = ADC_Convert(0);

Gestion.capt1=Gestion.capt1+Gestion.moyenne[i];

}

Gestion.calibre[0]=Gestion.capt1/50;//poid sans assiette

DelayMs(5);

LCDLine2(); // mettre le curseur ligne 1


do{

affichage_H_date();

MIF_Scan(); //fonction d'authentification lecteur RFID

Lire_RFID(); //lire les informations envoyé par le

lecteur RFID


for(i=0;i<50;i++){

Gestion.moyenne[i] = ADC_Convert(0);


}

Gestion.calibre[1]=Gestion.capt1/50;// poid avec 1 assiette

Gestion.diviseur_lin=((Gestion.calibre[1]-Gestion.calibre[0])-13);// poids d'1 assiette

//=((UC8)(1000/Gestion.calibre[1]));

LCDLine2();

Bin2BCD(Gestion.diviseur_lin);



LCDwrite(Least_Sig_Byte); DelaySec(3);

}


/*********************************************************************

Fonction d'attente avec un bip de validation

*********************************************************************/

void Attente(void)

{

PORTCbits.RC1 = 1;

DelayMs(80);

PORTCbits.RC1 = 0;

do{

affichage_H_date();



lecteur RFID


}

/*********************************************************************

Fonction d'attente avec bip continu

*********************************************************************/

void Attente_erreur(void)

{ PCD_output(rouge);

do{

affichage_H_date();

PORTCbits.RC1 = 1;

DelayMs(150);

PORTCbits.RC1 = 0;



lecteur RFID


PCD_output(vert);

}

/*********************************************************************

Information pour l'utilisateur

*********************************************************************/

void servez_vous(void)

{ UC8 TXT[21] = "Servez-vous! (max:";

text_display(TXT);

Badge.nb_possibe = (Badge.acquisition_donnee[2]-Badge.acquisition_donnee[1]);

Bin2BCD(Badge.nb_possibe);



LCDwrite(')');

}

/*********************************************************************

Fonction d'attente 4sec

*********************************************************************/

void temps4s(void)

{

I16 i,u;

for (u=0;u<6200;u++)

{

Nop();

for(i=0;i<40;i++)

{

}

Nop();

}


}

/*********************************************************************

Configuration du timer1

*********************************************************************/

void Config_d_interuption(void)

{

T1CON = 0x0B; //Config Timer1

PIE1bits.TMR1IE = 1; //mise à 1 du timer1

INTCONbits.PEIE = 1; //mise à 1 des périphériques d'interruption

INTCONbits.GIE = 1; //mise à 1 des d'interruptions globale

PIR1bits.TMR1IF = 0; //effacer timer1 et indicateur de débordement

TMR1H = 0x80; //chargement de la valeur du timer1

TMR1L = 0x00;

}

/*********************************************************************

Sauter à l'interruption

*********************************************************************/

#pragma code InterruptVectorHigh = 0x08

void InterruptVectorHigh (void)

{

_asm

goto InterruptHandlerHigh

_endasm

}

/*********************************************************************

Fonction de calibrage des capteurs

*********************************************************************/

#pragma code

#pragma interrupt InterruptHandlerHigh

void InterruptHandlerHigh (void)

{

//PORTB=0xFF;

if (PIR1bits.TMR1IF)

{

PIR1bits.TMR1IF = 0;

TMR1H = 0x80;

TMR1L = 0x00;

}

}

/*********************************************************************

Acquisition des 4 ports analogique

*********************************************************************/

void Acquisition_CAN(void)

{

for(Gestion.choix=0;Gestion.choix<4;Gestion.choix++)

{

switch(Gestion.choix)

{

case 0: Gestion.capt1 = ADC_Convert(Gestion.choix);

break;


break;


break;



break;

default:Gestion.erreur = 1;

}

}

}

/*********************************************************************

Fonction d'initialisation des diff variables

*********************************************************************/

void Initialisation_structure(void)

{

Gestion.capt1 = 0;

Gestion.capt2 = 0;

Gestion.capt3 = 0;

Gestion.capt4 = 0;

Gestion.choix = 0;

Gestion.erreur = 0;

Gestion.assiette1 = 0;

Gestion.assiette1_pr = 0;

Gestion.diviseur_lin = 47;

Badge.inc = 0;

Badge.type = 0;

Badge.prestation = 0;

Badge.ok = 0;

Badge.total[0] = 0;

Badge.total[1] = 0;

Badge.nb_possibe = 0;

Badge.num_caisse = 0x08;

Badge.code_site[0] =0x19;

Badge.code_site[1] =0xC9;

Badge.erreur = 0;

Badge.pas_bon = 0;

Badge.desk_num = 0x06;

Badge.transaction = 1;

Horloge.heu = 0x23;

Horloge.min = 0x59;

Horloge.sec = 0x30;

Horloge.jour = 0x02;

Horloge.date = 0x31;

Horloge.date_hier=0;

Horloge.mois = 0x12;

Horloge.mois_hier=0;

Horloge.annee =0x11;

Horloge.annee_hier=0;

}

/*********************************************************************

Fonction d'authentification lecteur RFID

*********************************************************************/

void MIF_Scan(void)

{







}

/*********************************************************************

Fonction lecteur RFID

*********************************************************************/

void MIF_Read_UID(void)

{


USARTWriteByte(0xB0);





{Badge.NumKey[Badge.inc] = USARTReadByte();}


}

/*********************************************************************

Fonction chargement de la clé A

*********************************************************************/

void MIF_loadkeya(void)

{


USARTWriteByte(0xD0);




while(USARTReadByte()!=0xD0);

USARTWriteByte(0xFF);







}

/*********************************************************************

Fonction de fermeture de la session

*********************************************************************/

void MIF_Close_session(void)

{


USARTWriteByte(0xE0);





}

/*********************************************************************

Fonction d'ouverture de la session

*********************************************************************/

void MIF_Open_Session(void)

{







while(USARTReadByte()!=0xA2);


{USARTWriteByte(Badge.NumKey[Badge.inc]);}

Badge.pas_bon=USARTReadByte();


}

/*********************************************************************

Fonction lecture du block

*********************************************************************/

UC8 MIF_Read_Block(UC8 block)

{


USARTWriteByte(0xB2);


USARTWriteByte(block);


}

/*********************************************************************

Fonction d'écriture du block

*********************************************************************/

void MIF_Write_Block(UC8 block)

{








{USARTWriteByte(Badge.acquisition_donnee[Badge.inc]);}


}

void MIF_Write_autre_Block(UC8 block)

{








{USARTWriteByte(Badge.acquisition_autre_donnee[Badge.inc]);}


}


/*********************************************************************

Lire les informations envoyées par le lecteur RFID

*********************************************************************/

void Lire_RFID(void)

{


{Badge.acquisition_donnee[Badge.inc] = USARTReadByte();}

if (Badge.acquisition_donnee[1]==0x01)

{Badge.ok=vrai;}else{Badge.ok=faux;}

}

/*********************************************************************

Lire les informations envoyées par le lecteur RFID UID

*********************************************************************/

void Lire_RFID_BLOCK(void)

{Badge.pas_bon=0;


{


{Badge.acquisition_donnee[Badge.inc] = USARTReadByte();}


}else

{USARTReadByte();

Badge.pas_bon=1;

}

}

/*********************************************************************

Lire les informations envoyées par le lecteur RFID UID

*********************************************************************/

void Lire_RFID_autre_BLOCK(void)

{Badge.pas_bon=0;


{


{Badge.acquisition_autre_donnee[Badge.inc] = USARTReadByte();}


}else

{USARTReadByte();

Badge.pas_bon=1;

}

}

/*********************************************************************

Fonction d'affichage des instructions utilisateur

*********************************************************************/

void utilisateur(void)

{

UC8 txt13[23] = "Mettre votre badge ";



}

/*********************************************************************

Fonction de conversion char en BCD

*********************************************************************/


void Bin2BCD (unsigned char temp)

{

Least_Sig_Byte = temp;

for (Most_Sig_Byte = 0 ; Least_Sig_Byte >= 100 ; Least_Sig_Byte>=100?(Least_Sig_Byte -=

100):Least_Sig_Byte, Most_Sig_Byte++ );

for (Middle_Sig_Byte = 0 ; Least_Sig_Byte >= 10 ; Least_Sig_Byte>=10?(Least_Sig_Byte -=

10):Least_Sig_Byte, Middle_Sig_Byte++);

Most_Sig_Byte += 0x30;

Middle_Sig_Byte += 0x30;

Least_Sig_Byte += 0x30;

}

/*********************************************************************

Fonction d'affichage de l'ID

*********************************************************************/

void Affiche_ID(void)

{

UC8 txt14[5] = "Num:";

UC8 txt16[2] = ".";



for(Badge.inc=5;Badge.inc>1;Badge.inc--) //aff du num badge

{

Bin2BCD(Badge.NumKey[Badge.inc]);




if(Badge.inc>2)

{text_display(txt16);}

}

}

/*********************************************************************

Fonction d'information pour la recharge d'assiette

*********************************************************************/

void Affiche_recharge(void)

{

UC8 txt20[23] = "Recharger assiette:";

do{assiette_actu();

LCDLine2();


Bin2BCD(Gestion.assiette1);




DelayMs(50);

affichage_H_date();

MIF_Scan(); //fonction d'autentification lecteur RFID


lecteur RFID


}

/*********************************************************************

Fonction d'acquisition de l'horloge temps réel

*********************************************************************/

void acq_horloge(void)


{

Horloge.sec = lire_ds1307(0x00);

Horloge.min = lire_ds1307(0x01);

Horloge.heu = lire_ds1307(0x02);

Horloge.jour = lire_ds1307(0x03);

Horloge.date = lire_ds1307(0x04);

Horloge.mois = lire_ds1307(0x05);

Horloge.annee = lire_ds1307(0x06);

if((Horloge.heu==0x23)&&(Horloge.min==0x59)&&(Horloge.sec>0x50))

{

Horloge.date_hier = lire_ds1307(0x04);

Horloge.mois_hier = lire_ds1307(0x05);

Horloge.annee_hier = lire_ds1307(0x06);

}

}

/*********************************************************************

Permet la conversion hexa DCB et l'affichage de l'horloge

*********************************************************************/

void affichage_H_date(void)

{

UC8 txt29[2] = ":";

UC8 txt30[2] = "/";

UC8 txt31[2] = " ";

UC8 conversion_DCB=0;

acq_horloge();

LCDLine1();

conversion_DCB = Horloge.heu/16; //Heure



conversion_DCB = Horloge.heu%16;




conversion_DCB = Horloge.min/16; //minute



conversion_DCB = Horloge.min%16;




conversion_DCB = Horloge.date/16; //date



conversion_DCB = Horloge.date%16;




conversion_DCB = Horloge.mois/16; //mois



conversion_DCB = Horloge.mois%16;




conversion_DCB = Horloge.annee/16; //année



conversion_DCB = Horloge.annee%16;




DelayMs(50);

}

/*********************************************************************

Envoi des trames pour la configuration de l'horloge temps réel

*********************************************************************/

void Chargement_horloge(void)

{

ecrire_ds1307(0x07,0b00010000);

ecrire_ds1307(0x00,Horloge.sec);

ecrire_ds1307(0x01,Horloge.min);

ecrire_ds1307(0x02,Horloge.heu);

ecrire_ds1307(0x03,Horloge.jour);

ecrire_ds1307(0x04,Horloge.date);

ecrire_ds1307(0x05,Horloge.mois);

ecrire_ds1307(0x06,Horloge.annee);}

/*********************************************************************

Conversion de poids en nombres d'assiettes

*********************************************************************/

void assiette_actu(void)

{UC8 i=1;

for(i=0;i<50;i++){

Gestion.moyenne[i] = (UI16)ADC_Convert(0);


}

Gestion.capt1=Gestion.capt1/50;

DelayMs(5);

Gestion.assiette1=(UC8)(Gestion.capt1/Gestion.diviseur_lin);

}

/*********************************************************************

Conversion de poids en nombres d'assiettes

*********************************************************************/

void assiette_prec(void)

{UC8 i=1;

for(i=0;i<50;i++){

Gestion.moyenne[i] = (UI16)ADC_Convert(0);


}

Gestion.capt1 = Gestion.capt1/50;

DelayMs(5);

Gestion.assiette1_pr = (UC8)(Gestion.capt1/Gestion.diviseur_lin);

}

/*********************************************************************

Commande de la LED du lecteur RFID

*********************************************************************/

void PCD_output(UC8 couleur)

{


USARTWriteByte(0xCD);


switch(couleur)

{

case 0: USARTWriteByte(0x7F);

break;


case 1: USARTWriteByte(0xBF);

break;

default:;

}


USARTReadByte();

USARTReadByte();

}

/*********************************************************************

Affichage du nombre d’assiettes prises par l’utilisateur.

*********************************************************************/

void affichage_nbautilisateur(void)

{

UC8 txt20[20] = "assiette(s) prise :";

LCDLine2();


Bin2BCD(Badge.total[0]);



}

Documents

Conception d’un pèse assiette débiteur de repas sur badge …darty30.free.fr/iut claude bernard/compte rendu/rapport... · 2011-06-16 · Conception d’un pèse assiette débiteur