CAN SAT US

Afficher l'image d'origine                                                                                                                           Logo-GEii-mulhouse

 

 

Afficher l'image d'origine

 

 

  MEREDIEU-JUNG Clément     BERTRAND Christopher      DECKER-WURTZ Alexis

 

 


SOMMAIRE:

 

 

 


 

Définition Cansat:

 

Cansat est un concours qui met en compétition plusieurs écoles, le but étant de larguer des petits modules, du même nom, en altitude. La descente sera gérée par parachute. Arrivée au sol, la Cansat devra réaliser plusieurs missions et mesures.

 

 


 

 

Cahier des charges:

 

Notre but était de concevoir et de réaliser une Cansat à l’aide d’un PIC18F4520 (microcontrôleur). Ce module devra être équipé d’un parachute, à dimensionner selon le poids de la Cansat, afin de faire atterrir en douceur cette dernière sur le sol.

Nous avons dû réaliser plusieurs missions et différentes mesures à l’aide de capteurs. Ces missions et mesures sont détaillées ci-dessous.

 

 


 

 

Missions:

 

  • Première mission: Nous devons indiquer à l’aide de leds de différentes couleurs les étapes de la phase de descente de la Cansat. Ces étapes représentent la distance entre le sol et la Cansat à trois mètres, un mètre et trente centimètres.
  • Deuxième mission: Elle consiste à transmettre toutes les informations de la Cansat, à savoir toutes les mesures effectuées au sol ainsi que celles prisent lors la phase de descente.
  • Troisième mission: Tenir 72h sur batterie, à savoir 4*1,5V, sans aucune alimentation externe.
  • Quatrième mission: Nous avons décidé que l’objectif de cette mission sera de détacher le parachute afin qu’il ne fausse pas les mesures réalisées.

 

 


 

 

Mesures:

 

1. Mesure pendant la descente:

    Nous allons effectuer des mesures de distances entre le sol et la Cansat à différents seuils. Ces seuils sont à trois mètres, un mètre et trente centimètres.
    Nous utilisons un capteur ultrason pour effectuer ces trois mesures.

 

Capteur_Ultrason_SRF05

 

Caractéristiques:

Alimentation: 5 Vcc

Consommation: 30 mA

Portée: de 10 cm à 3 m

Déclenchement: impulsion TTL positive de 10µs

Signal écho: impulsion positive TTL proportionnelle à la distance.

 

Au début nous devions utiliser deux capteurs: un capteur d’ultrason (SRF04) et un capteur infrarouge (GP2D120). Cependant notre capteur infrarouge était défectueux et le capteur d’ultrason SFR04 n’avait pas une plage de mesure qui incluait tout nos seuils. C’est pourquoi nous avons décidé d’utiliser le capteur d’ultrason SFR05 qui lui peut effectuer toute les mesures dont nous avons besoin.

 

 

2. Mesure au sol:

    Comme expliqué précédemment ces mesures seront effectuées une fois que le module sera arrivé au sol.

 

  • Capteur de température: LM35CAZ

températureCapture_temp       Capture_temp1

Caractéristiques:

Indice de température : -40 à +110 °C

Précision : ±0,75 °C (typique)

Gain de la sonde (sortie) : 10 mV/°C

Faible auto-échauffement : 0,08 °C sans courant d’air

Tension d’alimentation : +4 à +30 V c.c.

 

 

  • Capteur d’humidité: HIH-4000-003

 

humidité

Capture_hum              Capture_hum1

Caractéristiques:

donne l’humidité en pourcentage

Précision : ±3.5%

Tension d’alimentation : 4 à 5,8 V c.c.

Température de fonctionnement : -40 à +85 °C

 

 

 

 

  • Module capteur de lumière: Module capteur de lumière Electronic Brick

 

Le capteur de lumière va nous renseigner sur le niveau d’exposition à la lumière de la Cansat. On pourra savoir si la Cansat se trouve dans une pièce éclairée ou non par exemple.

luminosité

Capture_lum

Caractéristiques:

Consommation : 5mA

Alimentation : 5V

 

 

 

 

 

 

 

 

 

  • Capteur  de vibration: MEAS piezo

 

En prenant les valeurs brutes à la sortie du capteur nous avons créé différents seuils afin de détecter quand la CanSat est en déplacement , quand elle est posée sur une paillasse occupée ou non occupée (la CanSat sera entreposée dans une salle pendant les 72h de test).

 

Caractéristiques techniques:

Minimum d’impédance d’entrée : 1MΩ

Impédance recommandé : 10MΩ

Température de fonctionnement : -40 à 60°CdimVibration

 

 

Vibration
MEAS piezo

 

 

 

 

  • Capteur de son: Parkfun Sound Dectector (SEN-12642 ROHS)

 

Son

  • Caractéristiques techniques:

 

Tension d’alimentation : 3.5 à 5.5 V (idéalement 5V)

Gain en dB : 40 à 28

 

Ce capteur peut être utilisé de trois manières différentes, grâce à trois sorties distinctes: audio, envelope, gate.

 

 

Son_shéma

  • La tracé vert foncé représente la sortie audio du capteur. La tension de la sortie audio est directement la tension fournie par le micro. Ce qui veut dire que le son capté par le micro est directement retransmit à la sortie audio.
  • Le tracé vert clair représente la sortie envelope. Cette tension trace l’amplitude du son.
  • Le tracé rouge représente la sortie gate. Elle est booléenne, dès qu’un son est détecté la sortie passe à un niveau logique haut.

Nous avons choisi d’utiliser la sortie envelope de ce capteur pour pouvoir créer différents seuils de mesure.

 

 

Transmission des données:

Transmission des données par  deux Xbee pro s1 liaisons point à point.

xbee
Xbee

 

 


 

 

Contraintes:

cansat_parachute

  • Dimension des batteries imposées (tenir 72h sur 4*1,5V)
  • Dimension de la Cansat imposée
  • Poids (environ 350g)
  • Choc à l’arrivée
  • Récupération et/ou stockage des informations
  • Transmissions des données
  • Pas d’appendice avant le largage
  • Mettre un interrupteur on/off
  • Sécurité des personnes
  •  Dimensionnement du parachute
  • Budget

 

 


 

 

Stratégie:

 

  • Nous avons fait le choix de prendre des capteurs analogiques, cette solution nous à paru évidente car nous venons de voir le convertisseur analogique numérique sur le PIC18F4520 dans une de nos matières (Multi-tâches temps-réel).
  • Nous avons décidé d’utiliser uniquement le capteur ultrason pour effectuer toutes les mesures.
  • Concernant la programmation, nous utilisons plusieurs tâches dans le programme avec des priorités différentes.
      -Notre première tâche est une tâche d’initialisation.
      -La deuxième tâche sert à gérer la phase de descente de la Cansat, elle gère l’allumage des leds en fonction des différents seuils.
      -La troisième tâche est une tâche dans laquelle nous effectuerons les mesures des capteurs de température, humidité et luminosité.
               -La quatrième et dernière tâche envoie les mesures vers un hyper terminal via une liaison point à point grâce à deux Xbee pro s1.

 

  • Pour économiser le plus de batterie possible, nous avons choisi de basculer le PIC en mode veille entre chaque séquence de mesure.
  • Nous avions le choix entre transmettre et/ou stocker les informations. Notre choix à été de transmettre les informations de la Cansat toutes les 10min vers un hyper terminal

 

 


 

 

Tests réalisés:

 

  • Transmission des données:

Nous avons testé la transmission des données via deux Xbee pro s1 avec adaptateur usb. L’un des Xbee est en transmission et l’autre en réception, ils sont tout les deux branchés sur une plaquette de test différente et éloigné d’environ un mètre. Nous avons envoyé un compteur de 1 à 9 avec une base de temps d’une seconde et nous avons constaté que, hormis un décalage d’une seconde la transmission s’opère sans aucun problème.

test-xbee
Exemple avec capteur de température

 

 

  • Capteur de température:

Nous avons réussi à récupérer la mesure prise par le capteur de température puis nous l’avons traité via une formule pour la passer en degré Celsius. Cette opération est nécessaire sachant que le capteur renvoi une tension est non une valeur en degré Celsius.

test_temp
Essai du capteur de température sur plaquette de test

PICkit 2 branché à un PIC18F4520 qui récupère les information du capteur de température, les traitent puis les affichent sur l’afficheur LCD.

  • Plaquette de gauche sur laquelle est branchée un PIC18F4520, un capteur de température et un module Xbee pro s1 en mode transmission ainsi qu’un écran LCD qui affiche la température mesurée à l’aide du capteur. La plaquette est alimentée par une batterie de 4*1,5V.
  • Multimètre réglé en mode température et une sonde de température
  • Plaquette de droite sur laquelle est branchée un Xbee pro s1 en mode réception et un afficheur LCD sur laquelle s’affiche la valeur reçu par le Xbee.

On constate dans cette vidéo que quand on souffle sur le capteur de température et la sonde de température simultanément, la valeur qui s’affiche sur l’écran LCD de la plaquette de gauche est la même que le multimètre une fois que ce dernier s’est stabilisé. L’écart entre les valeurs indiquées sur le multimètre avant qu’il ne se stabilise et l’afficheur LCD est dû à la grande inertie du capteur. On remarque aussi que la valeur affichée sur la plaquette de droite  est la même que celle de la plaquette de gauche hormis un léger décalage dû au temps de transmission, donc on en conclut que la transmission est valide.

 

 

 

  • Capteur d’humidité:

Le but est de mesurer et de transmettre via une plaquette de test puis d’afficher le pourcentage d’humidité sur l’afficheur LCD d’une autre plaquette.

test_hum
Essai du capteur d’humidité sur plaquette de test

PICkit 2 branché à un PIC18F4520 qui récupère les informations du capteur d’humidité, les traitent puis les affichent sur l’afficheur LCD.

 

  • Plaquette de gauche sur laquelle est branchée un PIC18F4520, un capteur d’humidité et un module Xbee pro s1 en mode transmission ainsi qu’un écran LCD qui affiche la température mesurée à l’aide du capteur. La plaquette est alimentée par une batterie de 4*1,5V.
  • Plaquette de droite sur laquelle est branchée un PIC18F4520, un Xbee pro s1 en mode réception et un afficheur LCD sur laquelle s’affiche la valeur reçu par le Xbee.

Dans cette vidéo on voit que la valeur affichée sur l’afficheur LCD de la plaquette de droite est identique à la valeur sur l’écran LCD de la plaquette de gauche. On constate que quand on souffle dessus la valeur change et est envoyé via la transmission point à point des Xbee vers l’autre afficheur. On peut en conclure que la transmission est valide et que le capteur fonctionnne. On remarque néanmoins que les valeurs ne sont pas toujours les mêmes, cela est dû à l’inertie du capteur et au temps de transmission.

 

 

 

  • Capteur de luminosité:

Notre but n’était pas de visualiser les valeurs en lux ou en lumen mais d’étalonner le capteur pour qu’il nous donne une indication sur le type d’éclairage de l’environnement où se trouve la Cansat. Pour l’étalonnage nous avons pris des mesures de référence à divers endroits: dans une pièce sans fenêtres et toutes lumières éteintes, dans une pièce avec lumières éteintes mais ayant l’éclairage de fenêtres, une pièce éclairée par des lumières, sous exposition à une lumière forte, et capteur couvert (à l’ombre d’un objet).

test_lum
Essai du capteur de luminosité sur plaquette de test

PICkit 2 branché à un PIC18F4520 qui récupère les informations du capteur de lumière, les traitent puis les affichent sur l’afficheur LCD.

 

  • Plaquette avec PIC18F4520, afficheur LCD et module capteur de lumière.

On constate que quand on couvre le capteur la valeur diminue et quand on l’expose à la lumière la valeur augmente proportionnellement avec celle-ci.

 

 

  • Capteur ultrason:

Nous avons décidé de faire des paliers avec les données brutes que le capteur nous envoi. Cela est plus simple et tout aussi efficace. Nous avons ensuite ajouté des indicateurs visuels(leds) afin de visualiser les différents paliers (3m,1m,30cm) et ainsi vérifier la précision de  notre procédé. Nous avons aussi ajouté un capteur de contact afin de détecter atterrissage de la Cansat.

 

A trois mètres la led verte s’allume, à un mètre la led jaune s’allume et à trente centimètre la led rouge s’allume. Quand le capteur de contact est actionné, cela éteint toutes les leds et allume une autre leds rouge pour indiquer l’arriver au sol de la Cansat.

 

  • Capteur de vibration:

Le capteur que nous avons décidé de faire par la suite est le capteur de vibration. Si ce projet avait pu aboutir jusqu’au concours, il aurait servi à savoir si la CanSat était déplacé, entouré par des gens ou même un tremblement de terre. Mais comme celle-ci restera entreposée dans une pièce, nous avons décidé de rentrer 3 seuils de détection: déplacement de la Cansat, paillasse occupée, paillasse non-occupée.

Vib_Seuil

 

 

  • Capteur de son:

Nous avons installé ce capteur afin de détecter si la salle est occupée ou non.

son

Sur ce programme nous envoyons la mesure de l’intensité sonore puis selon nos tests nous avons créé des seuils pour nous informer si la salle est occupée ou non.

 

 


 

 

Gestion de la descente:

 

  • Tâche 0 : Tâche d’initialisation du pic18F4520.
  • Tâche 1 : Cette tâche sert à gérer la phase de descente. On y retrouve le code permettant de piloter les leds représentant les différents seuils, ainsi que le code permettant d’effectuer les mesures avec le capteur d’ultrason.
  • Tâche 2 : c’est la tâche réservé aux mesures des différents capteurs, qui sont tous analogique, ainsi que l’interprétation de ces mesures à la sortie du convertisseur analogique numérique(CAN).
  • Tâche 3 : Elle sert uniquement au décrochage du parachute par l’action du servomoteur.
  • Tâche 4 : C’est la tâche d’envoi des données. Par l’intermédiaire d’un Xbee nous envoyons, sur l’HyperTerminal de Windows, un affichage exposant clairement le nom des capteurs et les valeurs associées à ces capteurs ainsi que leurs interprétations.

 

 


 

 

Réalisation de la mission libre:

 

Rappel de la mission libre : décrochage du parachute avant l’atterrissage pour éviter de fausser les mesures si le parachute vient recouvrir la CanSat.

Pour cela nous utilisons un servomoteur: Anlog Servo de chez Makeblock.

Caractéristiques techniques:3L4A0335-800x800

  • Tension 4.8 à 6V
  • Couple 1.3 à 1.7  kg.cm
  • 0.10 à 0.09 sec/60°
  • 1000-2000 μsec

 

Pour réaliser cette mission nous avons intégré le servomoteur à la plaquette capteur de la CanSat. Nous avons ensuite ajouté deux axes sur le servomoteur qui partent de part et d’autre de la CanSat dans deux trous percés dans le tube en PVC afin de les bloquer pour pouvoir y accrocher les suspentes du parachute. C’est lors de la rotation du servomoteur que les axes vont sortir des trous et donc libérer les suspentes.

 

 

 


 

 

Fabrication physique de la CanSat:

 

IMG_20170327_184100

Notre CanSat est constitué de quatre plaquettes, toutes ces plaquettes sont reliées par l’intermédiaire de stack qui assure à la fois la tenu mécanique de l’ensemble et permet aussi de faire transiter toutes les entrées/sorties/alimentation du microcontrôleur sur chaque plaquette. Le tout est contenu dans un tube en PVC.

IMG_20170327_184119

  • Première plaquette: Plaquette de mesure, transmission de donnée et largage de parachute. Cette plaquette inclus donc tous nos capteurs(température, humidité, luminosité, vibration et son), le Xbee permettant la transmission de donnée, le servomoteur permet le largage du parachute et un switch on/off.
  • Deuxième plaquette: Plaquette sur laquelle se trouve la carte mère.
  • Troisième plaquette: Plaquette d’alimentation comportant quatre piles AAA branchées en série, un régulateur LM7805 qui régule la tension à 5V.
  • Quatrième plaquette: Plaquette de descente  comportant le capteur d’ultrason, les leds représentants les différents seuils de la descente et les contacts pour détecter l’arrivé au sol.

IMG_20170327_184126

 

 


 

 

Prototype du parachute:

 

  • Dimensionnement du parachute:Afficher l'image d'origine

Formule : (2*M*G)/(R0*Cx*V²)= Surface du parachute en m²

M : masse en gramme

G : 9,81 N/Kg

R0 : Masse volumique de l’air = 1,21

Cx : Coefficient de pénétration dans l’air = 1

V : vitesse en m/s

Nous avons trouvé une surface de 0,68m², donc un rayon de 46cm et donc un diamètre de 92cm.

 

Pour le prototype du parachute nous nous sommes servis d’un sac poubelle à défaut d’avoir une vraie toile.

Test réalisé à l’aide d’une bouteille d’eau avec une masse d’environ 350g pour modéliser le poids de la CanSat.

Ce test a été concluant, nous avons pu observer que le parachute ralentissait assez le poids fixé pour un atterrissage en douceur.

 

 

 


 

 

Problèmes rencontrés:

 

  • Vérifier la fonctionnalité de nos capteurs, car ils ont déjà été utilisés.
  • Chercher et trouver les bonnes datasheets et les formules de conversions des composants.
  • Le voltage des piles en mode embarqué qui été trop faible (inférieur à 4V) pour faire fonctionner les composants. Nous devions modifier les calculs afin d’intégrer le bon voltage quand les batteries étaient supérieures à 4V et donc utilisables, car quand la plaquette est branchée sur le PICkit 2 celui-ci délivre 4,80V.
  • La compatibilité et la protection des ressources lorsque nous avons réuni plusieurs programmes en un seul et même programme.
  • Gestion du temps: nous avons passé trop de temps sur la réalisation des programmes et pas assez sur la réalisation physique de la CanSat.
  • Non respect de la contrainte de volume , la CanSat est trop grande.

 

 


 

Avenir du projet:

  • Rechercher comment utiliser le mode veille du PIC18F4520 pour économiser les batteries.
  • Couper l’alimentation des capteurs entres chaque mesures à l’aide d’un transistor afin d’économiser les batteries.
  • Couper l’alimentation du servomoteur et de la plaquette descente (ultrason et leds)  à l’aide d’un transistor afin d’économiser les batteries, une fois la CanSat arrivé au sol.
  • Fabrication du parachute en toile.

 

 


 

 

Vidéo présentation du projet:

 

 

 

 


 

 

Remerciement:

Nous tenons à remercier Mr HAEBERLE, Mr VERRIER et nos collègues du projet Cansat IR.

 

 


CAN SAT IR

0MARIANJUDE Antony                  BRULANT Antoine02

 

 

cansat-course-in-india

 

SOMMAIRE

Introduction

Mission à réaliser

Nos contraintes

La phase de test

L’avancée du projet

La vidéo finale de la première partie

Avenir

Conclusion

 

Introduction

Définition CanSat :

CanSat est un concours qui consiste à mettre en compétitions plusieurs écoles ou associations en créant un dispositif, nommé CanSat.

Ce projet consiste en un petit système, lancé via un ballon, qui doit atterrir via l’utilisation d’un parachute. Puis une fois au sol, il doit effectuer différentes mesures et l’envoyer sur un ordinateur.

cansat

 

Le diagramme bête à cornes nous montre le but de ce projet. Les projets ER dans l’option informatique sont composés de 3 groupes avec 3 étudiants dans chaque groupe. Au départ nous étions 3 personnes mais finalement on est plus que 2 étudiants dans l’équipe.

a

 

 

Le diagramme pieuvre montre les contraintes et les différentes étapes que l’on doit accomplir pour réussir le projet.

bb

 

Voici notre GANTT qui est le planning du projet.Dans ce GANTT,il est représenté la partie étude du projet. La partie réalisation a été faite dans la semaine du 20 mars.

cc

-Gris : tâches en cours

-Rouge : tâches terminées


 

Mission à réaliser

Pour réaliser notre CanSat, nous utilisons un PIC18F4520 comme unité de contrôle, pour l’envoi des données, nous utilisons un module xBee qui permet à la CanSat de communiquer directement avec un pc équipé d’une clé USB adapté. Lorsque la CanSat est à terre, nous effectuerons ces mesures : Température,Humidité,Pression,Altitude et Luminosité.

Pour alimenter les capteurs, nous utilisons un module présent dans le PIC qui permet de diminuer la tension et d’alimenter les capteurs avec leur tension d’alimentation respective.
medium-PIC18F4520-TQFP-44prd-xbee-modules-fam

 


Nos contraintes

La contrainte majeure d’une CanSat est son volume, qui ne doit pas dépasser celui d’une canette de 33Cl. La taille des capteurs doit être réduite pour les placer dans la CanSat.

Les autres contraintes sont :

-Le prix, car nous disposons d’un budget limité.

-L’alimentation, car la CanSat doit pouvoir envoyer des données pendant au minimum 72h, grâce à 4 piles 1,5V chacune.

-L’organisation, nous devons disposer les capteurs pour qu’ils puissent fonctionner correctement, sans être gêné par la CanSat ou les autres capteurs, et aussi un module PIC, un xBee, et les 4 piles.

 

 

aa

 


La phase de test

 

aaaa

 

 

 

 


Partie 1

L’avancée du projet

CAPTEUR IR

Image

L’afficheur LCD à gauche simule la phase de descente de la CanSat : 1 la CanSat a une fort altitude   2 son altitude est moyenne  3 La CanSat est proche du sol  et 8 la CanSat est au sol. L’afficheur LCD à droite affiche les valeurs brutes de l’altitude de la CanSat.

Chaque capteur mesure une distance distincte. On active le capteur de grande distances, puis le capteur de moyenne distance et enfin le capteur de petite distance.
On envoie le numéro du capteur de l’on utilise via un module xBee.

 

CAPTEUR DE LUMINOSITE

 Image1

Le résultat affiché est « brute ».On affiche directement la tension de la sortie du capteur. La tension est inversement proportionnelle à la luminosité.

 

 

 

CAPTEUR D’HUMIDITE

Image2

On a utilisé le capteur d’humidité HIH-4000.Pour le branchement du capteur, on a regardé sur la fiche technique du composant.

 

 

CAPTEUR DE TEMPERATURE

On est en phase de test du capteur de température LM35CAZ. Il affichera la température de la pièce sur l’aficheur LCD.

ccc

 

 


 

 

La vidéo finale de la première partie


 

Avenir

 

On est dans l’attente des capteurs commandés(image ci-dessous). Quand on les recevra,on va devoir les calibrer et mettre ensemble tout les capteurs.

capteurs

 

On doit également mettre en place le mode veille du pic18f4520 afin que l’on consomme peu lorsque la CanSat prendra ses mesures au sol. Les capteurs d’altitude devront être éteint lorsque la CanSat sera au sol et on mettra un bouton poussoir afin que l’arrivée au sol soit détectée par la CanSat.

On doit également mettre en place le parachute et la portabilité du programme finale via le pic18f4520.

 


 

Conclusion

On a également travailler sur la partie Etudes des Etudes et Réalisation. Il nous reste à finir toute la partie réalisation. Au semestre 4,on continuera ce projet.

On remercie Monsieur HAEBERLE et nos collègues du projet CanSat US.



 

Partie 2

Pour ce dernier semestre à l’IUT, notre projet d’Etude et Réalisation est la suite du projet Cansat IR. Dans la première partie, nous avons fait le test des différents capteurs pour les mesures scientifiques et pour la détection du sol. Dans cette deuxième partie, nous allons approfondir la phase de détection du sol et faire un programme qui regroupera tous les capteurs que l’on utilisera.

Les nouveaux capteurs qu’on a reçu sont :

 

1

Voici,le capteur de Gaz, il détecte la pollution,le méthane…

Le tableau ci-dessous qui vient de la datasheet du composant, montre les différentes mesures prises par ce capteur.

gaz

 

La phase étude du capteur

Lorsque le capteur ne détecte aucune pollution dans l’air :

5

 

Lorsque le capteur  détecte de la pollution dans l’air(ici émanant du briquet) :

6

 


 

Pour les capteurs suivant(ceux en rouge),ce sont des capteurs en protocole I2C.

 

Capture

 

 

 

3

MPL3115A2(PRESSION_I2C)

 

 

 

 

 

 

MMA84542Q(ACCELEROMETRE triple axes_I2C)

 

 

 

 

 

Par un retard sur le projet et un équipier en moins, on a passé les capteurs I2C. Vous pouvez voir ci-dessous leur fonctionnement.

 

Le capteur de pression :

 

L’accéléromètre triple axes :


 

En ce qui concerne la mission libre, on a choisi un module GPS mais la datasheet du composant n’était pas présente. On aurait pu choisir la norme Sony du programme Arduino pour faire notre programme. Le composant est arrivé vers la fin du projet.

 

Le module GPS :

2


 

Avec Hyperterminal et les modules Xbee, nous avons conçu un programme qui permet de lire à distance les valeurs prises par les différents capteurs pour la partie « Mesures scientifiques ».

Pour la partie détection au sol, nous avons rencontrés certains conflits pour transformer le programme qui affichait directement la valeur du capteur infrarouge sur l’afficheur LCD en programme qui simule la valeur du capteur infrarouge via une led de couleur.

Après plusieurs échecs, nous avons finalement réussi à simuler cette descente comme vous pouvez le voir dans la vidéo ci dessous :

 

Comme vous pouvez le voir dans cette vidéo, lors ce que la main approche du capteur IR :

-Grande distance: la led rouge s’allume

-Moyenne distance:la led jaune s’allume

-Courtes distance:la led verte s’allume

Et lorsque le bouton poussoir est appuyé toutes les leds s’allume. Il nous reste également à changer cette partie,c’est-à-dire lorsque le bouton poussoir sera enclenché on passera du programme « Détection du sol » au programme « Prises des mesures scientifiques ».


 

Pour la partie mesure scientifiques,voici les mesures des capteur affichés sur l’ordinateur via le logiciel Hyperterminal (quelques parties repris sur l’application bloc-notes suite à une indisponibilité de l’ordinateur pour les captures d’écran sur Hyperterminal):

 

bbbbb

cccc

Ces mesures représentent les valeurs prises par les capteurs IR.

Pour le mode « sleep », nous avons pu éteindre la Cansat avec la procédure Sleep( ) mais on n’a pas réussi à la réveiller.


 

Maintenant passons à la partie Physique de la Cansat.

7

 

Sur cette image,nous avons commencé la partie physique de la Cansat,le premier étage est composé des capteurs pour les mesures scientifique.Le second étage est dédié au PIC18F4520 et le troisième étage est pour l’alimentation avec 4 piles de 1,5 V chacune. Dans le dernier étage nous avons les capteurs infrarouges comme l’on peut le voir sur cette photo :

 

8

Cette Cansat sera protégé par un tube en PVC lors de son arrivée au sol.

9

On a également placé une nappe entre le pic18f4520 et le pickit pour faciliter la programmation de la Cansat.


Remerciements

Merci d’avoir lu cet article sur notre projet Cansat IR. On tient à remercier Monsieur HAEBERLE pour les conseils et l’aide qu’il nous a fourni pour le projet Cansat et pour nos présentation.Cela nous aidera à nous améliorer pour notre soutenance de stage qui clôturera notre DUT. Et on remercie le groupe Cansat US pour l’aide qu’ils nous ont fourni pour les plaquettes de la Cansat.

 

 


Rewamping SIEMENS

Capture d’écran 2017-03-15 à 16.51.18

Capture d’écran 2017-03-15 à 16.51.27

Rewamping SIEMENS

P_20170320_113653_vHDR_On

Membres:  Mathar DIAKHATE , David LE, Nicolas KANGHNI


Sommaire

Introduction

I) Présentation de l’équipement

II) Notre travail

III) Identification des organes de l’automate

IV) Programmation de l’automate 

V) Fonctionnement d’un cycle

VI) Avancement du projet

VII) Difficultés rencontrées

Conclusion


Introduction

Dans le cadre de notre formation en DUT Génie électrique et informatique industrielle , nous sommes amenés à réaliser un réaliser un projet en groupe sur une durée de 100 heures sur les semestres 3 et 4 dans le but de mettre nos acquis en pratique ainsi que nous préparer au stage.

C’est ainsi que nous avons choisi de faire le projet Rewamping de l’automate Siemens.

Le Rewamping est une pratique couramment utilisée de nos jours pour remplacer un automate dans une chaîne de production. Elle consiste à vérifier si l’automate fonctionne correctement en faisant une mise à jour logicielle.

Siemens_S7-400

I) Présentation de l’équipement

Nous avons à notre disposition une mini-chaîne de production de pièces comprenant deux automates SIEMENS qui nous a été fourni par le département Génie mécanique et productique de L’IUT de MULHOUSE.

Cette chaîne  est composé de 2 parties : la partie triage & acheminement et la partie contrôle des pièces de production. Chacune des deux parties est gérée par un automate différent.

P_20170320_113653_vHDR_On

1) La partie contrôle des pièces

Cette partie est gérée par l’automate S7-300Sv

P_20170316_093238_vHDR_On

Celui ci est composée de 3 parties:

  • l’alimentation électrique de l’automate (à gauche)
  • L’automate lui même (au centre)
  • Les entrées sorties directes (à droite)
  • Les entrées sorties déportées par bus ASI permettant d’économiser des fils (à l’extreme droite avec le cable jaune)

Les élements principaux constituants la partie contrôle des pièces sont les suivants:

  • Un vérin permettant d’amener les pièces vers le palpeur

P_20170120_112130_vHDR_Auto

  • Un palpeur va mesurer la hauteur des pièces

P_20170120_112148_vHDR_Auto

  • Une table de commande comprenant un bouton marche, un mode fonctionnement manu/auto et un arrêt d’urgence.

P_20170120_112212_vHDR_Auto

  • Un distributeur d’air permet d’alimenter l’air au palpeur et au vérin.

P_20170120_120332_vHDR_Auto

  • Une électrovanne permettant d’alimenter ou de couper l’air arrivant au palpeur

P_20170316_093443_vHDR_On

  • Un capteur de pression permettant de connaitre la pression d’arrivée d’air au palpeur

P_20170316_093424_vHDR_On

  • Une alimentation électrique indépendante pour les bus ASI en 24V /4,2A

P_20170316_093348_vHDR_On

  • Des interfaces ASI permettant de communiquer avec l’automate

P_20170120_120326_vHDR_Auto

2) La partie acheminement et triage des pièces

Cette partie est gérée par l’automate S7-300HHG & SM

P_20170320_110936_vHDR_On

Celui ci est composée de 3 parties:

  • l’alimentation électrique de l’automate (à gauche)
  • L’automate lui même (au centre)
  • Les entrées sorties directes (à droite)
  • Les entrées sorties déportées par bus ASI permettant d’économiser des fils (à  droite des entrées sorties directes avec le cable jaune)
  • Une interface USB (à l’extrême droite)

Les éléments principaux constituants la partie acheminements et triage des pièces sont les suivants:

  • Un vérin permettant d’amener les pièces vers le capteur permettant de trier les pièces

P_20170320_111025_vHDR_On

  • Plusieurs interfaces ASI ( Partie vérin et celui du robot tournant) permettant de communiquer avec l’automate

P_20170320_111003_vHDR_On  P_20170320_110949_vHDR_On

  • Un robot tournant permettant de saisir les pièces par  dépression

P_20170320_111107_vHDR_On

  • Une commande électrique permettant de faire tourner le robot

P_20170320_112502_vHDR_On

  • Un distributeur d’air permettant d’alimenter un vérin acheminant les pièces et celui du robot tournant

P_20170320_111051_vHDR_On

  • Des capteurs permettant la présence et la couleur de la pièce permettant de faire ensuite le triage

P_20170320_111011_vHDR_On

  • Une alimentation électrique indépendante pour les bus ASI en 24V /4,2A

P_20170320_111131_vHDR_On

  • Des câbles profibus (en violet ) permettent de relier les deux automates

P_20170320_113653_vHDR_On

II) Notre travail

Faire la programmation de chacun des automates sur un cycle pour vérifier son fonctionnement et proposer des solutions d’optimisation

III) Identification des organes de l’automate

Nous nous sommes d’abord intéréssé dans un premier temps à la partie contrôle des pièces

P_20170120_112148_vHDR_Auto

Nous avons fait un inventaire des entrées et sortie présentes sur le banc d’essai

Les entrées correspondent aux capteurs qui fournissent des informations à l’automate et les sorties aux actions de l’automate (boutons poussoirs, arrêt d’urgence).
Elles sont répertoriées dans le tableau ci-dessous.

Désignation Entrée ou sortie connexion Type de capteur Fonction
B1 Entrée Slave 1 TOR Capteur position Vérin rentré
B2 Entrée Slave 1 TOR Capteur de position vérin sorti
B3 Entrée Slave 2 TOR Capteur de position Palpeur en Haut
B4 Entrée Slave 2 TOR Capteur de position Palpeur bas
S1 Entrée Slave 1 TOR Bouton d’arrêt d’urgence
S3 Entrée Slave 1 TOR Bouton marche machine
S4 Entrée Slave 2 Mode manu /auto
H2 Sortie Slave 4 TOR Voyant Marche
H3 Sortie Slave 4 TOR Voyant d’arrêt d’urgence
S5 Entrée Slave 3 TOR Capteur présence pièce
Y1 Sortie Slave 5 TOR Distribution d’air vérin entrée
Y2 sortie Slave 5 TOR Distribution d’air vérin sortie
Y3 Sortie Slave 5 TOR Distribution d’air Palpeur

Nous avons deux types d’entrées/ sortie:

  • Les directes qui sont directement connecté à l’automate par des fils
  • Celles déportés par bus ASI  connectant les slaves 1, 2, 3, 4 et 5 à l’automate et d’éviter d’utiliser un grand nombre câble pour connecter les capteurs.

IV) Programmation de l’automate

Nous avons du faire dans un premier temps fait deux types de grafcets

  • Le grafcet de production normale, permettant de décrire le cycle de fonctionnement normale de la partie opérative

P_20170122_173416_vHDR_Auto

  • Le grafcet de conduite permettant de passer soit en mode manu ou auto

P_20170122_174844_vHDR_Auto

nous avons ensuite transformer le grafcet en ladder en 3 parties

a) Pré traitement et post traitement

  • Le prétraitement correspond à l’appellation de chaque transition du grafcet à celle que l’on veut définir dans le logiciel de l’automate. La transition correspond à l’information donnée par le capteur. Dans notre cas S3 et S2 correspond à To
  • Le post-traitement correspond à l’appellation de chacune des actions du grafcet à celle que l’on veut définir dans le logiciel de l’automate. Dans notre cas H2 (rentrée du vérin) correspond à l’étape 1

P_20170122_192114_vHDR_Auto

b) Traitement

Le traitement correspond au cycle que l’automate doit décrire.

P_20170122_192104_vHDR_Auto

Une fois après avoir la conversion des grafcets en ladder , nous les rentrons dans le logiciel STEP 7

On définit dans le logiciel plusieurs blocs où nous allons mettre nos grafcets :

P_20170328_104102_vHDR_Auto

Ensuite nous rentrons notre grafcet dans le bloc choisi .

Cas pour les transitions

P_20170120_112925_vHDR_Auto

Cas pour le grafcet

P_20170120_112831_vHDR_Auto

Nous devons ensuite faire une identification des adresses

Habituellement la plupart des automates récents font une saisie automatique des adresses des entrées et des sorties connectées à l’interface ASI. Dans notre cas, il faudra faire la saisie manuelle.

Nous cherchons tout d’abord à déterminer la correspondance entre la table et l’adresse de l’esclave.

P_20170120_120326_vHDR_Auto

Nous avons 5 esclaves (appelées slave) qui sont connectés au bus ASI. 4 correspondent à des entrées (sur lesquels sont connectés les capteurs) et 2 à des sorties (boutons marche, mode manu auto, arrêt d’urgence et distribution d’air) .

Sur le logiciel nous avons les adresses d’entrée référencées par PEW 272 (E signifie eingang = entrée) et de sortie par PAW 274 (ausgang= sortie) détectée par le logiciel

Les adresses vont de 272 à 274.

Nous faisons ensuite bouger par exemple le palpeur pour savoir quel voyant s’allume. Si le voyant se situe en bas on peut dire que l’adresse du capteur appartient au bit de poids fort s’il est situé en bas ou de poids faible s’il est situé en haut du slave.

Nous faisons cela pour chacun des 5 slaves.

Le nombre d’adresse de bits de poids fort ou de poids faible va déterminer si le slave sera de poids fort ou faible .

Nous avons la correspondance suivante:

56

Une fois que l’on a trouvé les adresses pour chaque capteur ou actionneur, on les rentre dans la table des mémoniques.

P_20170120_124140_vHDR_Auto

V) Fonctionnement d’un cycle

Lorsque une pièce est détectée, le vérin initialement sorti se rétracte. Le palpeur descend pour vérifier si la pièce est à la bonne hauteur puis remonte. Ensuite le vérin ressort puis un nouveau cycle recommence.

La commande du vérin et du palpeur est assurée par un distributeur d’air. Une électrovanne permet de d’alimenter ou de couper l’air au palpeur.

1552

 VI) Avancement du projet.

Jusqu’à présent le cycle de production des pièces ne fonctionnait qu’en mode manuel

Durant le semestre 4 , nous nous sommes focalisés sur la programmation permettant de basculer soit en mode manuel ou automatique .

Le mode manuel permet à chaque pression sur le bouton marche (ou start) de palper une fois la pièce . Ce mode est utilisé lorsque les pièces à contrôler ne sont pas nombreuses .

Le mode automatique permet à chaque pression sur le bouton marche (ou start) d’enclencher plusieurs cycles de palpage à la présence d’une pièce. Ce mode est utilisé lorsqu’il y a plusieurs pièces à contrôler à la fois.

Afin de procéder à la programmation de ces deux modes, nous avons adopté la démarche suivante:

Pour ce faire nous avons dû faire ,tout d’abord le grafcet de conduite .

P_20170122_174844_vHDR_Auto

Après quelques corrections

P_20170329_074344_vHDR_Auto

Nous le rentrons ensuite dans le logiciel , avec l’étape de départ caractérisée par E100

P_20170316_112503_vHDR_On

Puis nous modifions les adresses dans la tables des mémoniques:

P_20170120_124140_vHDR_Auto

Durant cette partie, nous avons eu quelques soucis à cause de conflits entre les adresses, il nous a été impossible d’avoir les deux modes à la fois , nous pouvons soit le faire fonctionner en mode auto , soit en mode manuel.

Une fois le problème corrigé avec notre professeur tuteur Mr VIGNE, nous pu avoir les deux modes mais lorsque l’on enclenche le mode manuel, à chaque pression sur le bouton marche , le palpeur palpe la pièce 2 fois.

Ensuite nous nous sommes intéressés à la partie acheminement et triage des pièces (à droite)

P_20170328_112506_vHDR_Auto

Comme pour la partie 1, nous avons fait une identification des entrées et sorties

Capteur entrée sortie connexion type Fonction
B9 x Slave 6 TOR Verin sorti
B8 x Slave 6 TOR Verin rentré
S3 x Slave 6 TOR bouton marche ou start
S4 Slave 6 TOR Manu/auto
S1 x arret d’urgence
H2 x slave 4 TOR Voyant marche
H3 x slave 4 TOR Voyant manu/auto
H1  x TOR voyant arret d’urgence
B11 x slave 5 TOR Capteur luminosité (détecte la couleur)
B10 x slave 5 TOR Capteur pièce métallique
S11 slave 5 TOR Capteur présence pièce
Y1 x slave 7 TOR distribution d’air vérin
Y2 x slave 7 TOR distribution d’air vérin
Y3 x slave 7 TOR distribution d’air robot
y4 x slave 7 TOR distribution d’air robot
S8 x slave 3 TOR capteur de position plateau
S9 x slave 3 TOR capteur de position plateau
S10 x slave 3 TOR capteur de position plateau
s21
s20
B5 x slave 2 TOR capteur de position
B1 x slave 1 capteur de vitesse plateau robot
B6 x slave 3 capteur verin bas robot
B7 x slave 3 capteur verin haut robot

Une fois les entrées sorties identifiés nous avons fait le grafcet de la partie opérative

P_20170329_092415_vHDR_Auto

Nous avons ensuite traduit en langage à contact en ladder et décomposé en 3 parties: prétraitement,traitement, postraitement

P_20170329_092429_vHDR_Auto

Une fois cela fait, pour gagner du temps nous avons dupliqué le programme de la partie contrôle des pièces pour gagner du temps dans lequel nous complétons et modifions les valeurs.

P_20170316_102622_vHDR_On

Une fois cela fait, nous intéressons ensuite à l’identification des adresses

P_20170329_092444_vHDR_Auto

le logiciel détecte les entrées PEW et sorties PAW

Nous devons ensuite jouer sur les capteurs pour connaitre les bits des adresses.

Par manque de temps et comme certains capteurs ne fonctionnaient pas , nous nous sommes arrêtes à la partie identification des adresses

VII) Difficultés rencontrées

Nous avons rencontrés quelques difficultés à travers ce projet

  • Concernant  l’utilisation du logiciel Siemens step 7 qui était différente de TIA Portal que nous avions eu l’habitude d’utiliser au cours de nos séances d’automatisme. Il s’agit d’une version plus ancienne où nous devons faire la saisie manuelle des adresses des entrées sorties avec l’automate. Il nous arrive de temps à autre de nous tromper d’adresse et le cycle ne démarre pas
  • Nous avons pris notre temps pour découvrir comment configurer l’automate sur le Logiciel STEP 7
  • Nous avons pris du temps à configurer la commande de basculement en mode Manuel ou Automatique
  • Concernant la partie acheminement & triage des pièces certains capteurs ne fonctionnent pas (par exemple ceux permettant de connaitre la vitesse de rotation du plateau du robot)

P_20170320_112502_vHDR_On

  • l’alimentation en air ne fonctionnait pas pour la partie acheminement & triage des pièces, on ne savait pas comment la raccorder.

P_20170320_113701_vHDR_On

Pour les raisons précédemment cités et par manque de temps, nous n’avons pas pu terminer la partie triage et acheminement des pièces et participer à l’amélioration de cette mini-chaine de production

Malgré les difficultés rencontrés, nous avons  programmé l’automate de la partie acheminement des pièces en mode hors ligne et résoudre le problème de faux contact de certain capteurs ( notamment ceux du plateau du robot).

Nous avons essayé de comprendre le fonctionnement du circuit d’air permettant d’alimenter le vérin et le robot permettant de saisir les pièces en identifiant les capteurs mentionnant la présence d’air .

Pour les problèmes d’adressages concernant le mode manu/auto de la partie contrôle des pièces nous avons testé plusieurs fois le grafcet (hors ligne et en ligne avec l’automate ) pour voir si  toutes les étapes et transitions sont validés .

 

Conclusion

Au cours de ce projet, nous avons pu revoir un certain nombre de notions abordés en cours d’automatisme et d’informatique  à travers les différentes tâches qui nous ont été confiés

  • Langage LADDER ou à contacts
  • Le grafcet de production normale et de conduite
  • Identifications des entrées et sorties
  • Identifications des adresses entre les esclaves et l’automate.

Nous avons eu l’occasion de découvrir un nouvel environnement logiciel, le logiciel SIEMENS  STEP 7 -permettant de programmer l’automate S7-300SV et S7-300HHG&SM qui est différent à celui utilisé en salle de TP d’automatisme.

Ce sujet nous a permis d’approfondir nos connaissances sur la programmation des Automates Programmable Industriel (API) et comprendre leur fonctionnement .

Nous tenons à remercier Monsieur MERKLE , Monsieur COLLUCCIO et Monsieur VIGNE nos professeurs tuteurs qui nous suivis et consacrés leurs temps à nous aider durant ce projet.


Malaxeur

Élèves en charge du projet :

Aladin SEDIRI et Arthur LAVALLEE.

 

Introduction :

Pour notre projet d’étude et réalisation nous travaillons sur le malaxeur. L’armoire été en cours de rénovation mais on nous à finalement charger de la réaliser. Le projet a pour but de refaire en grande partie le câblage de l’armoire électrique du malaxeur et de sa partie opérative ainsi que la programmation de l’automate et de l’interface homme/machine.  Pour cela nous avons procédés en plusieurs étapes.
Capture.3

 

Principe de fonctionnement du malaxeur : 

Avant de vous détailler les différentes étape du projet nous allons vous lister certains des composant et capteur afin de mieux comprendre comment fonctionne le malaxeur.

Le malaxeur est composé d’un automate et d’un variateur de vitesse qui vont tout deux gérer le mode de fonctionnement automatique et d’un pupitre pour gérer le mode de fonctionnement manuesi que gérer la sélection du mode de fonctionnement. Le pupitre possède également des voyants et des boutons pour gérer une partie de la sécurité du système.

Le système possède également une cuve pour accueillir les matériaux à malaxer ou mélanger, une pâle pour le malaxage,une plaque chauffante positionnée en dessous de la cuve pour pouvoir faire chauffer les matériaux présent dans la cuve, d’une sonde de température pour s’assurer que la température de chauffe de la plaque soit adaptée au matériaux présent dans la cuve,un première moteur que sera piloté par la variateur de vitesse pour pouvoir modifier la vitesse de rotation de la pâle, un seconde moteur pour pouvoir faire monter et descendre la pâle, il possède également des capteur de position tout ou rien (TOR) pour pouvoir s’assurer de la présence de la cuve et de la position (haute ou basse) de la pâle.

 

Etape de réalisation du projet :

La première étapes a été d’étudier le schémas électrique du malaxeur afin de bien identifier les différents composants présent dans l’armoire électrique et dans la partie opérative pour pouvoir s’adapter et donc ajouter ou enlever des composants selon nos besoin.

 

20170122_230549        20170122_230729  20170122_230651

 

La seconde étape a été d’enlever  tout les repères et de retirer tout les câbles de l’ancienne installation afin de tout recâbler correctement selon les nouveaux plans de câblage.

la troisième étape a bien évidement été le recâblage en prenant bien soins de repérer tout les câbles selon le nouveau schémas afin de pouvoir repérer les différents câbles et intervenir rapidement en cas de panne du système.

 

Capture                    Capture.2                    Capture.4

la quatrième étape sera l’étape de test de l’armoire électrique hors tension à l’aide d’un ohm mètre pour vérifier si tout les composant de l’armoire sont raccordés correctement selon les plans de câblage et si il n’y a pas d’éventuel cours-circuit pour ne pas endommager les composant de l’armoire électrique.

Et la cinquième et dernière étape sera la programmation de l’interface homme/machine (écran tactile) ainsi que la programmation de l’automate qui tous deux  servirons au bon fonctionnent du malaxeur.

 

capture.1

 

Problèmes rencontrés :

Notre plus gros problème a été le manque de temps car le décâblage et le recâblage à été une étape très longue de ce projet. Nous avons également eu quelque petit problème durant le câblage notamment  sur le raccordement de la terre et des masse car il nous devions utiliser des borniers que nous n’avions pas sur le moment mais nous avons résolut rapidement ce petit soucis.

 

Avancement du projet :  

Nous avons recâblé la totalité de la partie opérative, de l’armoire électrique ainsi que le câblage de l’automate et du variateur, seul la liaison entre l’automate et le variateur n’a pas été faite. il reste cependant beaucoup de travail car il faut encore  contrôler chaque connexion entre les différents organes de commande et de sécurité avec un ohm mètre pour s’assurer qu’il n’y a pas de mauvais branchement et donc d’éventuel cours-circuit et faire la programmation de l’automate et de l’interface homme/machine.

 

17619721_1250015785117488_1740081122_n(image montrant l’automate câblé)

 

Conclusion : Ce projet a été très intéressant pour nous car il nous permet d’appréhender l’aspect technique d’un projet c’est à dire toute la partie câblage d’une machine et d’une armoire électrique, nous n’avons cependant pas pu réaliser la partie informatique de ce projet c’est à dire toute la partie programmation d’un automate et d’une interface homme/machine tel qu’un écran tactile mais nous avons pu expérimenter cette aspect du projet lors de travaux pratique réaliser en cours.

Nous voudrions remercier Mr Vigne, Mr Colicchio ainsi que Mr Merckle nos professeurs tuteurs sur ce projet et Mr De Sabbata responsable de l’IUT Lab, pour l’aide qu’ils nous ont fournis tout au long de ce projet.

 

 


Vision sur Robot TX60

Rapport projet TX60

Cahier des charges

 

  • Utilisation d’un robot six axes Stäubli TX60, équipé de son Teach et programmable via la suite logicielle Stäubli.
  • Utilisation d’une caméra noir et blanc intelligente NI1722 Smart Camera, programmée via le logiciel NI Vision Builder.
  • Connexion entre la caméra et le robot via une connexion Ethernet TCP.
  • Le robot doit être capable de reconnaitre des pièces de différentes formes, réparties sur une surface pouvant changer de taille et/ou de position.
  • Le robot ne doit pas entrer physiquement en contact avec la caméra.
  • La préhension des pièces se fera au moyen d’une ventouse qu’il faudra dimensionner et adapter au robot.

Objectif du projet

Ce projet doit mettre en place une interaction entre un robot six axes Stäubli TX60 et une caméra industrielle. Le but est de retirer des pièces de différentes formes du champ de vision de la caméra, en établissant une communication entre celle-ci et le robot afin de partager les coordonnées des pièces. Le robot doit ensuite retirer les pièces du champ de vision de la caméra, en fonction d’une « recette » dictée par l’utilisateur.

 

La caméra

La caméra utilisée pour le projet est une NI1722 Smart Camera. L’avantage d’avoir une caméra « intelligente » est de pouvoir se passer d’un ordinateur pour le traitement des images. Ainsi la prise de vue, la reconnaissance des pièces et le calcul de leurs coordonnées se fait directement du côté de la caméra et seules les coordonnées des pièces sont envoyées au robot.

 

Le robot

Le robot six axes Stäubli TX60 nous permet dans ce projet de déplacer les pièces. Il communique avec la caméra industrielle via une liaison Ethernet TCP, lui permettant de récupérer les coordonnées des différentes pièces. Le Teach  permettant de contrôler le robot manuellement et la suite Stäubli permet de créer et tester une bonne partie du programme directement sur un simulateur. Le programme peut aussi être modifié directement sur le Teach, mais le manque d’ergonomie le destine surtout à faire des modifications sur le terrain.

 

La ventouse

La ventouse, couplée à un générateur de vide type venturi, est de taille très réduite. L’avantage d’une petite ventouse est de pouvoir avoir une erreur plus importante lors du pointage des pièces par le robot. L’ensemble, monté sur un support fixé au bout du bras du robot, est relié à l’arrivée d’air via le système pneumatique du robot. La ventouse et le générateur de vide ont été acheté sur le site https://www.smc.eu/portal_ssl/webpages/01_products/products.jsp sous les références :

  • ZPT10BF-A6 pour la ventouse
  • ZH05DL-06-06-06 pour le générateur de vide

Ventouse TX60Venturi TX60

 

 

 

 

Le fonctionnement

 

Le programme permettant la manutention des pièces se résume en plusieurs étapes :

  • La définition du repère caméra : le support de travail est doté de 3 points permettant de définir le repère de la caméra. Une fois le support et les trois points de repère placés dans le champ de vision de la caméra, celle-ci créé automatiquement le repère et calcule la variable permettant de faire la conversion millimètres / pixels.

Acquisition de l’image :Acquisition TX60

Binarisation de l’image :Binarisation TX60 Définition du repère de la caméra :Definition repere TX60

 

  • Importation des coordonnées des pièces : pour cela, il suffit d’aller dans le menu correspondant et de sélectionner les coordonnées des pièces qui nous intéressent. Le robot va ensuite demander à la caméra de faire une prise de vue et de renvoyer les coordonnées des pièces en pixels, puis faire la conversion pixels/millimètres via une variable nConversion calculée au préalable. Les coordonnées de chaque pièce s’affichent une fois acquises par le robot.

Conversion TX60

 

 

  • Sélection de la « recette » : ce menu permet à l’utilisateur de choisir les pièces qu’il souhaite conserver dans le champ de vision de la caméra. Une fois que les pièces à conserver sont sélectionnées, le robot va automatiquement retirer les pièces indésirables et créer une pile de pièces pour chaque forme. Il serait aussi possible de faire l’inverse, en remplissant une boîte avec les pièces demandées par exemple. Après avoir fini sa manœuvre, le robot retourne en position initiale et attend l’acquisition de nouvelles pièces et/ou d’une nouvelle recette.

Recette

 

Conclusion

Ce projet nous a permis d’améliorer nos compétences sur certains points. Pour commencer, l’utilisation réelle d’une caméra industrielle apporte plusieurs manières de traiter un même problème de vision industrielle. Il faut prévoir l’éclairage, le fond sur lequel travailler en fonction de la couleur des pièces, ou encore la distance de focalisation de la caméra. La partie robotique, quoique plus facile à programmer grâce à la possibilité de faire une simulation sur le logiciel Stäubli, nous a néanmoins posé quelques problèmes de communication avec la caméra. Pour finir, nous pouvons dire que le projet pourrait être approfondi en prenant en compte la possibilité d’avoir plusieurs pièces de même forme, ou travailler en tenant compte des couleurs, ce qui nécessiterait un changement de caméra.

Projet réalisé par BOYARD André-Julien et SINGER Vincent.


Déstockage par Robot TX40

Projet déstockage par robot Tx40

 

Membre du groupe

MULLER Quentin et DUBY Luc

 

Présentation du projet

 

Ce projet consiste à utiliser le robot Tx40 et l’automate de stockage. Le but de ce projet est grâce au robot de chercher les pièces de l’automate de stockage, de les prendre puis de les déposer en palette par colonne de deux pièces. L’utilisateur pourra choisir quelle pièce il voudra prendre (rouge, noir ou métallique) et/ou faire des combinaisons telles que rouge/noir ou bien métallique/rouge par exemple.

 

 

Présentation de l’équipement

 

Pour ce projet, nous avons utilisé le robot Tx40, c’est un robot articulé avec 6 degrés de liberté de la marque Stäubli.

 

 

robot
Robot Tx40

 

 

Nous avons aussi utilisé l’automate de stockage pour amener les pièces dans le bon compartiment. C’est un automate de la marque Siemens que nous avions déjà vu en première année en API.

 

 

siemens
Automate de stockage

 

 

Réalisation

Pour la réalisation de ce projet, nous avons utilisé différents logiciels de programmation.

  • Pour la partie automate, nous avons utilisé le logiciel Siemens TIA Portal. Cela permet des programmer des automates (API) grâce à des programmes en ladder.

 

ladder
Programmation du choix des différentes pièces
  • Pour la partie robot, nous avons programmé grâce au logiciel Staubli ou directement grâce à la commande du robot.

 

 

          Commande

commande

 

Programmation

progra
Programme du start qui défini le menu de choix

 

                                                                                  

La programmation du robot est la partie la plus importante du projet, la plus longue et la plus difficile. Durant la programmation nous avons quelques problèmes comme le problème de collision avec l’automate quand le robot prend les pièces ou alors quand le robot ne peut pas aller à un endroit dû à un encombrement. Le fais de programmer directement sur la commande à été difficile et long car nous avons jamais fais cela avant. Le deuxième problème à été que le robot ne faisait pas exactement ce que la simulation montrait.

 

Rendu visuel du projet

A ce jour, le robot empile correctement chaque recette (r/r, n/n,m/m,n/m,n/r et r/m). Ce qu’il manque encore est le fais de faire plusieurs recettes à la fois, car il y a un problème dans les transformées du programme.

Nous n’avons pas réussi à arriver à la partie communication entre le robot et l’automate qui nous permettrait une gestion de nombre de pièce grâce aux différents compteurs.

 

Semestre 4

 

Présentation du projet

La suite du projet consiste à utiliser le robot Tx40 et l’automate de stockage. Le but de ce projet est, grâce au robot, de chercher les pièces de l’automate de stockage, de les prendre puis de les déposer dans chaque emboitement des différents socles. L’utilisateur pourra choisir quelle pièce il voudra prendre (rouge, noir ou métallique) et/ou faire des combinaisons telles que rouge/noir ou bien métallique/rouge par exemple.

 

Création de socle

Nous avons du créer deux socles grâce à une machine de découpe au laser, les différentes pièces s’emboiteront dans chaque emboitement un a un.

 

Image1
Socle en bois

 

Programmation

Après avoir étudié le nouveau but du projet, nous avons regardé si nous pouvions reprendre des parties de notre ancien programme. La partie du programme de prise des pièces est inchangé, mais toute la partie dépose a du être refaçonner.

Image2

 

Communication

Un autre but du projet était de mettre en place un communication TCP/IP entre l’automate et le robot Tx40 pour pouvoir connaitre le nombre de pièces dans l’automate.

 

 

Image3
Automate programmable industriel

 

 

Image5
Robot Staubli Tx40

 

Image4
Programme de communication TCP/IP

 

Nous avons d’abord essayé une communication local grâce à un hyperterminal. Nous avons pu envoyer un caractère qui correspondait à la détection de pièce dans l’automate. Cet essai à réussi et donc nous avons pu passer à l’étape suivante.

Nous avons alors essayer la communication entre le robot et l’automate sans succès.

 


Serveurs sur Ethernet

Rapport du projet de semestre 3 : serveurs sur Ethernet

logo-uha

IUT Génie Electrique et Informatique Industrielle de Mulhouse

Logo-GEii-mulhouse

2016-2017

 

 

Table des matières:

1 Introduction

2 Rapport

2.1 Serveur DHCP

  • 2.1.1 Définition
  • 2.1.2 Réalisation
  • 2.1.3 Aller plus loin
  • 2.1.4 Tutoriels

 

2.2 Serveur SMTP

  • 2.2.1 Définition
  • 2.2.2 Réalisation
  • 2.2.3 Aller plus loin
  • 2.2.4 Tutoriel

 

3 Conclusion                                                                                                               

4 Remerciements                                                                                                    

 

 

 

1 Introduction

 

Dans le cadre du 3ème semestre du DUT Génie Electrique et Informatique Industrielle de Mulhouse, nous avons pu choisir un projet à réaliser en binôme sur une période de trois semaines pour un total de 60 heures. Le projet a eu lieu dans les bâtiments du département GEII à Mulhouse du 3 au 20 janvier 2017. Ce projet a été encadré par un professeur tuteur, dans notre cas il s’agissait de Monsieur MERCKLE.

Pour ce projet, il nous a été demandé d’étudier, mettre en œuvre et de pouvoir expliquer différents serveurs qui utilisent le support Ethernet. Ces serveurs sont DHCP, NTP, MTP, SDM ainsi que le DNS.

Notre binôme a été constitué de M. FALLAHI et de moi même, M. HUEBER. Suite à une absence répétée de mon binôme, je me suis retrouvé seul sur ce projet. Il ne m’a donc pas été possible de réaliser tout ce qui avait été demandé. Etant donné que nous travaillions séparément sur ce projet, cela n’a pas eu d’influence sur l’avancée de ma partie que j’ai pu réaliser dans de bonnes conditions.

Je vais donc vous présenter les deux serveurs que j’ai mis en place, le serveur DHCP et le serveur SMTP.

 

  • 2 Rapport

  • 2.1 Serveur DHCP :

  • 2.1.1 Définition

 

Qu’est ce que le serveur DHCP ?

Le serveur DHCP, de l’anglais Dynamic Host Configuration Protocol, est le protocole qui permet d’attribuer une configuration IP aux différents appareils d’un même réseau lors de leur mise sous tension.

Où trouve t’on ce protocole ?

Le DHCP est généralement couplé au routeur de votre réseau, c’est donc un protocole autonome, lors de la connexion d’un nouvel appareil, nous n’avons rien à faire pour obtenir une adresse IP. Dans notre cas, nous voulions comprendre son fonctionnement et pouvoir l’étudier, nous avons donc créé notre propre serveur DHCP et nous l’avons configuré pour qu’il fonctionne sur notre réseau.

Comment ca fonctionne le DHCP ?

  1. Lorsqu’un appareil (le client) est branché sur le réseau, il va envoyer une demande d’adressage sur le réseau, on appelle cette demande le broadcast. Pour être sûr que le serveur DHCP reçoive sa demande, il envoie ce broadcast à tout le réseau, soit sur l’adresse IP 255.255.255.255.
  2. Une fois que la demande arrive au serveur, ce serveur va envoyer une offre (DHCP offer). Dans cette demande se trouve l’adresse IP que propose le serveur au client ainsi que l’adresse IP du serveur pour que le client puisse lui répondre.
  3. A ce stade, le client envoie une requête DHCP (DHCP request) au serveur pour lui dire qu’il accepte l’offre et demande à l’obtenir.
  4. Le serveur confirme que l’adresse IP du client lui a été assignée.

Ces 4 étapes sont visibles sur la capture de trame ci dessous effectuée avec Wireshark au moment de la connexion d’un nouvel appareil sur le réseau :

wireshark

Sur cette trame on peut bien distinguer les 4 étapes : la demande, l’offre, la requête et la validation

2.1.2 Réalisation :

Pour réaliser ce serveur, il nous a été mis à disposition deux terminaux sous Windows XP. Nous avons donc pu chercher et installer un logiciel nous permettant de configurer un serveur DHCP. Nous avons retenu le logiciel OpenDHCPserver et l’avons téléchargé via le site internet dédié. Ce logiciel est gratuit.

DHCP_serveur_client

Image des deux terminaux utilisés

 

 

La création et la configuration du serveur DHCP n’ont pas été très compliquées grâce à des tutoriels en anglais et une utilisation simple du logiciel.

invite commande serveur

Voici l’invite de commande du serveur une fois lancé

 

 

Maintenant que nous avons un serveur DHCP, il a fallu créer des clients pour confirmer le bon fonctionnement de notre serveur. Nous avons donc utilisé le deuxième terminal à notre disposition. Sa configuration en client DHCP n’a pas été compliquée car cette opération est déjà intégrée au système d’exploitation de Windows.

démarche

Voici la démarche à suivre pour qu’un PC soit client DHCP, cliquer sur « obtenir une adresse automatiquement »

Une fois le client configuré, le serveur détecte la demande DHCP et l’adressage se fait automatiquement comme on peut le constater sur l’image ci dessous avec l’offre, la requête et la validation.

invite commande 2

Maintenant le serveur configuré et testé, nous avons essayé de réaliser un même serveur et client avec des automates. Pour cela nous avons utilisé deux automates B&R de la même salle de travaux pratiques. Pour nous familiariser avec la fonction DHCP sur automate nous nous sommes servi de l’aide fournie avec le logiciel de l’automate. Il se trouve que l’automate comporte une fonction serveur DHCP, ce qui nous a facilité la tâche. Nous avons tout de même dû renseigner des informations essentielles pour qu’il soit configuré comme nous le voulions.

automate

automate B&R utilisé pour le serveur DHCP, identique à celui utilisé pour le client DHCP

Pour configurer le client DHCP sur le même modèle d’automate, nous avons procédé de la même manière, en choisissant cette fois ci la fonction client DHCP.

Les vérifications du bon fonctionnement du client DHCP et plus encore du serveur DHCP n’ont pas été évidentes car l’automate ne dispose pas d’écran. Nous ne pouvions donc pas connaître l’adresse IP qu’il aura attribué au client DHCP, et encore moins savoir s’il a bien assigné une adresse IP au client DHCP. Pour ce faire nous avons utilisé le client DHCP sur ordinateur pour vérifier le fonctionnement du serveur DHCP automate. Pour vérifier le bon fonctionnement du client DHCP automate nous avons utilisé le serveur DHCP présent sur l’ordinateur, tout en vérifiant que le serveur DHCP automate est bien éteint au moment du test.

2.1.3 Aller plus loin :

 

Après discussion avec le service informatique et Monsieur MERCKLE pour avoir des renseignements sur le fonctionnement du serveur DHCP de l’Université de Haute Alsace (UHA), nous nous sommes dit qu’il serait judicieux de pouvoir attribuer une adresse IP fixe en fonction de l’adresse MAC du client automate de la salle de travaux pratiques.

Après vérification, le logiciel OpenDHCPserver permet cela. Nous avons donc attribué une adresse IP fixe pour chaque automate de la salle de TP. Pour que les automates reçoivent leur adresse IP, il faudra à chaque début de TP configurer l’automate comme client DHCP, opération simple à effectuer.

Capture d’écran de la configuration de OpenDHCPserver pour assigner une adresse IP en fonction de l’adresse MAC

IP MAC

2.1.4 Tutoriel

Pour permettre aux futurs étudiants de réaliser dans de bonnes conditions tout ce que nous avons présenté plus haut, nous avons réalisé trois tutoriels :

  • Création d’un serveur/client DHCP sur ordinateur
  • Création d’un serveur/client DHCP sur automate
  • Assignation IP en fonction de l’adresse MAC avec OpenDHCPserver

tuto dhcp

Ces trois tutoriels ont étés réalisés avec la même structure que ceux créés par M. MERCKLE pour qu’il y ait une facilité de lecture pour les étudiants

2.2 Serveur SMTP

2.2.1 Définition

 

Le serveur SMTP, Simple Mail Transfer Protocol, est un protocole permettant d’envoyer des mails. C’est lui qui a le rôle du facteur si on compare les mails au courrier que l’on envoie par la poste.

  • Mais peut on écrire un mail avec le serveur SMTP ?

Non, le serveur SMTP récupère les mails que l’on aura écrits avec un webmail (messagerie en ligne), ou avec notre serveur de messagerie tel que Outlook, l’application Mail, les messageries sur Smartphone ou dans notre cas le logiciel de messagerie Thunderbird.

  • Comment fonctionne le serveur de messagerie ?

Le serveur de messagerie est une interface sur laquelle on peut consulter ses mails, en envoyer, en recevoir. Pour pouvoir l’utiliser il suffit de renseigner son adresse mail et son mot de passe, mais dans notre cas, comme nous aurons créé nous même notre serveur SMTP, nous allons devoir faire quelques étapes en plus pour que notre serveur de messagerie soit opérationnel.

2.2.2 Réalisation

 

Pour mettre en place le serveur SMTP, nous avons pu dans un premier temps nous appuyer sur le rapport de projet d’étudiants de l’année précédente qui avaient eux même mis en place un serveur SMTP. Toutefois leur rapport n’indiquant pas le mot de passe administrateur permettant d’accéder aux commandes du serveur, nous avons donc dû créer un nouveau serveur en nous aidant de leur tutoriel.

Le logiciel qu’ils avaient utilisé est hMailServer, nous avons donc décidé d’utiliser ce même logiciel. Nous l’avons installé sur le même ordinateur qui a servi à créer le serveur DHCP.

hMailServer est un logiciel gratuit qui possède une très grande communauté sur son forum, ce qui nous permettra par la suite de résoudre des problèmes si nous sommes amenés à en rencontrer.

hmail1

Une fois le logiciel installé, nous avons dû choisir un mot de passe simple à retenir pour accéder à la partie administrateur du logiciel. Nous avons donc choisi le mot de passe : hmail. Nous avons créé notre domaine « mail.local » puis des adresses mail, pour pouvoir effectuer des tests par la suite. Il y avait également quelques réglages à faire indiquer dans le tutoriel fait par les anciens étudiants. Nous avons suivi ce tutoriel à la lettre pour être sûrs que notre serveur fonctionne à la fin de la configuration.

Une fois le serveur configuré, pour pouvoir le tester il nous fallait un serveur de messagerie. Nous avons choisi Thunderbird car il était déjà installé sur des ordinateurs présents dans la salle de travaux pratiques. Ce logiciel est gratuit.

Après installation et configuration des adresses mail pour que Thunderbird reconnaisse le serveur SMTP, nous avions nos adresses mail prêtes à être utilisées.

Thunderbird1

Les premiers tests ne se sont pas avérés très concluants. Des messages d’erreur s’affichaient sur Thunderbird. Ces messages indiquaient ne pas pouvoir se connecter au serveur sortant et pourtant des mails arrivaient bien à destination. Cela voulait donc dire que la configuration de notre serveur SMTP sur hMailServer n’était pas bonne. Résoudre ces problèmes a pris beaucoup de temps. Nous avons dû nous servir de la communauté de hMailServer et de tutoriels en ligne car le tutoriel mis à disposition des anciens étudiants était incomplet et ne permettait pas réellement de configurer entièrement le serveur SMTP.

Thunderbird2

2.2.3 Aller plus loin

Monsieur MERCKLE nous a informé que les automates dont nous disposons ont une fonction permettant d’envoyer des mails. Cette étape avait été réalisée par les anciens étudiants mais aucune trace écrite du protocole suivi n’avait été faite. Nous avons donc suivi la documentation du constructeur de l’automate pour le configurer. Une fois l’automate opérationnel nous avons essayé d’envoyer des mais vers le serveur SMTP. Nous avons tout de suite eu un mail d’erreur de la part de l’automate indiquant que le mail n’a pas pu être envoyé, sans plus de détail.

logiciel automate

Capture d’écran de la partie à configurer dans le programme du constructeur d’automate

 

Pour trouver la source du problème, nous avons utilisé Wireshark, un logiciel de capture de trâme pour observer à quel moment du transfert se trouve le problème. Voici à quoi ressemble une capture de trâme avec Wireshark :

Shark1

Le message d’erreur étant « SMTP authentification is required », nous savions donc a ce moment que le problème ne venait pas de l’automate mais de la configuration du serveur SMTP. Après consultation du forum de discussions de hMail, nous avons pu corriger ce problème et permettre le fonctionnement du protocole.

Shark2

Voici la même trame SMTP une fois le problème résolu

Thunderbird3

Capture d’écran de Thunderbird une fois le serveur SMTP entièrement fonctionnel

2.2.4 Tutoriel

Comme pour le serveur DHCP, nous avons créé un tutoriel complet permettant de recréer un serveur SMTP avec les logiciels hMailServer et Thunderbird. Ce tutoriel a déjà été testé par M. MERCKLE et lui a permis de créer l’intégralité de ce qui vous a été présenté sans grande difficulté.

3 Conclusion

 

Après trois semaines de projet, en binôme puis seul, j’ai réussi à mettre en place deux serveurs, le serveur DHCP permettant d’assigner des adresses IP fixes aux différentes machines de la salle de travaux pratiques et le serveur SMTP lui aussi fonctionnel puisque nous pouvons envoyer des mails depuis tous les ordinateurs de la salle mais également envoyer des mails depuis un automate.

Il y a eu des moments assez longs où j’ai perdu du temps sur des petits problèmes que j’ai finalement réussi à résoudre grâce aussi à l’aide de M. MERCKLE.

Ce projet a été enrichissant pour moi, j’ai découvert le fonctionnement de deux serveurs que j’utilise dans mon quotidien sans savoir auparavant comment ils fonctionnaient.

Tout ce qui avait été demandé n’a pas été effectué mais les parties effectuées ont été bien développées, avec dans chaque cas la création d’un tutoriel qui pourra servir aux prochains étudiants.

4 Remerciements

Nous tenons à remercier Monsieur MERCKLE, enseignant tuteur qui nous a suivis tout au long du projet et qui a su prendre le temps de nous aider quand nous en avions besoin. Nous souhaiterions également remercier le service informatique avec qui nous avons pu échanger sur leur fonctionnement, ce qui nous a permis d’avoir de nouvelles idées et donc d’étoffer notre projet.

 

Maxime HUEBER-MOOSBRUGGER


Modbus TCP

IMG_4314

Membres du groupe

SCHNELL Vincent & PIVERT Anthony

 

Présentation du sujet

Durant notre 3ème semestre de notre formation Génie Electrique et Informatique Industrielle (GEII), nous sommes à nouveau amené à réaliser un projet. Nous avions le choix entre différents sujets qui concernait soit le domaine de l’automatisme, soit le domaine du réseau industriel. Nous devions choisir 1 sujet de chaque domaine. Nous avons été reçu sur notre 2ème vœu qui est Modbus TCP.

Cahier des charges

diagramme « bête à cornes » :

cornes

 

 

diagramme « pieuvre » :

pieuvre

 

 

Tableau présentant la fonction principale et les fonctions contraintes :

fonctions

 

Gestion du projet

 

  • Faire fonctionner dans un premier temps une lampe (1.7 A)
  • Programmer l’interface
  • Etude pour la fabrication d’une carte de puissance
  • Réalisation de la carte de puissance
  • Faire fonctionner feux de brouillard arrière, feu de plafond, phare, clignotants, ventilateur0, feux de freins
  • Activer ces composants à partir d’une interface avec des boutons
  • Interfaçage, fixations et câblages

 

Réalisation de la carte de puissance :

Avant de réaliser la carte, il fallait déjà connaître les caractéristiques des lampes, et en fonction choisir les composants qui correspondent. Donc il a fallu tester les feux.

Ci-après se trouve une image résumant les tests des différents feux, et le tableau comportant toutes les valeurs trouvées :

Mesure des feux Mesure du feux arrière

Feu avant                                                                                                                        Feu anti-brouillard arrière

 

 

valeurs voyants

Ces tests nous ont permis de voir l’intensité maximum qui devra traverser la carte et donc adapter la carte pour cela.

Pour la réalisation de cette carte, nous avons besoin : 3 borniers de 2, 2 borniers de 3, 2 diodes (de roue libre) « classiques », 2 relais et de 2 fusibles. Ensuite, la réalisation de cette carte se fait en 2 temps : premièrement, il s’agissait de réaliser la carte sur le logiciel Kicad et deuxièmement de la fabriquer.

L’étape Kicad se fait en 3 étapes ; il faut réaliser le schéma, créer la netliste associé pour enfin s’occuper du pcb. Le schéma que j’ai créé sur Eeschema est le suivant :

schema kicad entier

J’ai du changé le module du relais car il ne correspondait pas au mien. Par simplification, j’ai fait la moitié du schéma, et j’ai copier/coller pour avoir un schéma bien aligné et pour bien s’y retrouver. Avec ce schéma, j’ai généré la netliste qui suit :

kicad netliste

A l’aide de cette Netliste, j’ai ouvert pcbnew. J’ai changé l’empreinte du fusible et des relais pour qu’ils correspondent aux tailles de mes composants.

Fusible : module fusible

Relais :

module relais

Une fois les composants bien disposés sur la carte, je pouvais créer les pistes. Un détails mais pas des moindres, toutes les pistes ne seront pas de la même taille puisqu’elles conduiront des courants différents. Ci-après se trouve le pcb de la carte de puissance.
kicad pcb

La difficulté se trouve surtout dans la taille des pastilles et des trous puisque les pattes des composants doivent rentrer dans les trous.

 

Après quoi, il suffit d’imprimer le pcb en faisant apparaître les trous, les pastilles, les pistes et de bien vérifier que les trous ont la bonne taille et le bon espacement par rapport aux composants. Une fois fait, je suis passé à la fabrication de la carte.

Ma carte faisant à peu de chose près 10cm sur 10cm, j’ai pris un circuit imprimé et je l’ai coupé pour avoir les dimensions précédentes. Ensuite les étapes s’enchainent ; il faut graisser le dos de la feuille imprimé, placé la feuille ainsi que le circuit imprimé (démuni de son scotch bleu) aux UV en faisant bien attention d’être bien sur le circuit et j’ai mis une insolation d’une durée de 2’40 », j’ai passé la carte au révélateur puis dans la machine afin que la carte ne conserve que les pistes et les pastilles, et enfin passé la carte à l’étamage. On finit par faire les trous et les soudures en respectant le schéma. Et voila la carte de puissance!

Ici les images correspondants aux différentes étapes dans l’ordre chronologique :

IMG_4311IMG_4307IMG_4312

 

IMG_4308IMG_4310IMG_4306

 

Maintenant que la carte de puissance est créé, image suivant :

 

Il s’agit donc de la tester afin de vérifier qu’elle est fonctionnelle et qu’elle correspond aux attentes.

Test feux arrière avec automate                        Test feux avant avec automate                        Test des deux feux

Programmation:

On a dû réaliser un programme pour faire une démonstration du projet à l’aide de l’automate qui pourra activer les sorties que l’on à programmé.

Automates :Automate

 

Ensuite on pouvait commander ces sorties sur un IHM (Interface Homme-Machine)

 

IHM:IHM

 

 

Voici le programme qui nous a permis de réaliser la fonction clignotant d’une voiture.

Programme clignotant

Comme vous pouvez le voir le programme est sur une sortie que l’on alterne entre TRUE (vrai) et FALSE (faux) avec d’avoir le clignotant. Le seul inconvénient était la vitesse de clignotement. Pour subvenir à cet inconvénient on à régler la vitesse du compteur qui réglait l’action entre le TRUE et le FALSE. On a du pour cela changer le temps de cycle du CPU  qui était de 1000 ms. On l’a divisé par deux pour avoir un clignotant optimal donc 500 ms.

Cpu PROGRAMME

————————-

Continuité du projet au semestre 4

 

 

Au semestre 4, nous avons eu la chance de pouvoir continuer notre projet afin de le finaliser entièrement. Le but étant de commander tous les feux.

Nous avons commencé par la duplication de la carte initiale, et nous en avons fait 5 autres en suivant le même procédé.

Exemple de l’étape des UV.

IMG_4457

Après tous les perçages et les soudures réalisés, nous nous sommes occupés du câblage en suivant le schéma suivant:

schéma

 

Ensuite nous avons améliorer l’interface en fonction. En effet, en rassemblant les feux par catégorie par le câblage, nous avons fait de même sur l’interface. Par contre, nous avons reçu qu’une partie de la dernière commande, ce qui a pour effet qu’on ne peut pas commander tous les catégories de feux comme les feux de position par exemple.

Notre professeur M. Mercklé nous a aussi procuré une batterie plus puissante qu’au semestre 3. En effet, auparavant nous étions limité à 6 ampères, et désormais nous sommes limités à 10 ampères ce qui nous permet d’allumer 2 catégories de feux en même temps au maximum (à part les feux de brouillard, car il y a 3 feux dans cette catégorie).

IMG_4608

Du coté logiciel on à réaliser u ne fonctionnalité dédier au phare : l’appel de phare du programme que vous trouverez ci dessous:

Partie Lampe

Dans cet partie on a du mettre en place des lampes avec un automates wago qui les commandes.

automate lu                                                les 2 lampes

On a mis en place l’automates wago on a du régler les sorties relais(en rouge) qui était en tout ou rien (0 1) et les sortie analogiques(en bleu) on était plus compliqué à mettre en oeuvre car il fallait trouver les tensions de commande qui sont de 0V à 10V. Et sur l’automates il sont codés sur 12 bits , cet sortie analogique nous sert pour faire varier l’intensité des ampoules. Sur l’IHM on a mis une nouvelle page dédier à cet automates avec des sliders qui permette de régler l’intensité des ampoules à distance .

 programmation slider

 

 

Conclusion

Nous sommes arrivés à finaliser ce projet. Un projet est toujours intéressant et celui ci n’a pas fait exception. En effet, en tant que Technicien Supérieur nous devrons aussi savoir comment dimensionner, modéliser et réaliser une carte de puissance devant répondre aux besoins et pouvant faire face aux contraintes, programmer un automate et un interface, mettre en oeuvre une maquette, câbler et fixer. Malheureusement on a pas pus aboutir la fonctionnalités des lampes par manque de temps mais on a réaliser plus de la moitié du travail sur cette partie.Nous tenons à remercier nos professeurs, notamment M. Merckle, notre tuteur, pour avoir répondu à nos différentes questions, pour nous avoir conseillé et guidé.

 

 


OPC UA

Omeid EHSAN                                                                                   Rayan BENMAMMAR

vous présentent

IUTGEII

 

 

 

 

LA COMMUNICATION OPC-UA

opcua

 

1

 

 

 

 

Sommaire :

 

– Introduction

 

1 – Présentation et Cahier des Charges

 

2 – Déroulement du projet / Mise en œuvre

 

3 – Difficultés rencontrées

 

– Conclusion

 

 

2 4

 

 

Introduction

 

OPC Unified Architecture (OPC UA) est un protocole de communication indépendant des fabricants pour les applications d’automatisation industrielle, tel qu’Automation Studio qui est le logiciel que nous utiliserons dans ce projet.
Il est basé sur le principe client-serveur, donc nous aurons un CPU Client et un CPU Serveur. Le protocole flexible, fiable, sécurisé et complètement indépendant. OPC_UA utilise le réseau Ethernet pour la connexion entre les CPU et pour les échanges de données.
Il a été récemment intégrer à Power Link.

 

1 – Cahier des Charges

 

Pour ce projet, mis à part OPC_UA, nous avons utilisé comme matériels 2 CPU X20-3586 utilisées pour le client et le serveur. La CPU 200.200.200.174 est pris comme Serveur et la CPU 200.200.200.184 comme Client.

Les programmations des programmes clients et serveur ont été créés grâce au logiciel Automation Studio version 4.25, car ce n’est qu’à partir de la version 4.2 qu’OPC_UA est utilisable sur ce logiciel. C’est avec cet environnement de développement logiciel qu’est Automation Studio que nous avons pu aussi faire la visualisation de nos programmes.

Le but principal de notre projet était de s’approprier la fonctionnalité de la « Communication OPC-UA » entre différentes CPUs. Ainsi nous avons pu appliquer les différentes fonctions réalisables grâce à l’OPC-UA et les expliquer dans un tutoriel pour que d’autres étudiants puissent également les réaliser. Pour cela, nous avons utilisé la rubrique « Aide » du logiciel Automation Studio pour comprendre les différentes fonctions réalisées par cette communication OPC-UA à l’aide de diagrammes et explications données en anglais.

Voici par exemple le diagramme expliquant la fonction « Lecture » :

5

Le CPU Client va lire le contenu de la variable présente dans le CPU du Serveur grâce à la communication OPC-UA entre les 2 CPU

 

Une fois ce diagramme compris, nous devions passer à la pratique et réaliser cette fonction en configurant les programmes, les CPUs ainsi que les visualisations afin de modéliser concrètement la communication OPC-UA pour un meilleur rendu esthétique.

 

2 – Déroulement du projet

 

Tous les sous projets se sont déroulés dans le même ordre :
1- Configuration des CPUs
2- Création du projet Serveur
3- Création du projet Client
Les programmes et la configuration étant déjà faites, nous avons pu tester la communication en simulation sur le PC. Nous avons dû développer les Visu des clients et Serveur pour pouvoir visualiser les fonctions mises en place. Puis après la simulation sur pc, nous sommes passés sur la communication entre 2 CPUs. Le programme Client était connecté a à la CPU 200.200.200.184 et le serveur à la CPU 200.200.200.174.

Pour cela il y avait quelques changements à opérer dans les programmes, spécialement dans le client, où il fallait spécifier l’adresse IP et le port TCP du serveur. Après avoir finis les visualisations des différentes fonctions, nous avions à faire le tutoriel expliquant comment importer les programmes constructeurs, comment faire d’une CPU un serveur et l’autre un client, quels changements étaient nécessaire à la communication entre les CPU et enfin comment faire les Visu.

 

 

Après avoir finis ce premier tutoriel, il nous a fallu recréer les programmes, mais cette fois ci entièrement. Nous avons dû trouver toutes les bonnes configurations à faire, ce qui n’a pas vraiment été chose simple, mais nous avons finalement réussis. Nous avons mis beaucoup de temps pour trouver toutes les petites subtilités qui permettait à la communication de fonctionner, mais l’aide dans Automation Studio nous a bien aidés.

Comme précédemment, nous avons terminé par un tutoriel expliquant toutes les configurations nécessaires au développement des programmes utilisant une communication OPC_UA. Ces tutoriels seront utilisés par les étudiants pour de futurs projets ou TP Réseaux.

 

Voici le rendu final de la fonction « Lecture » de la communication OPC-UA.
Cette visualisation modélise la communication réalisée en temps réel :

6

Les 5 premiers boutons à droite permettent d’établir la connexion entre les CPUs et de réaliser la communication avec l’échange de données d’une CPU à l’autre.
La valeur du compteur du serveur (à gauche) s’affiche dans la Visu du Client (à droite) à l’instant t. Ainsi toutes les demi-secondes (période configurable) la valeur de « VarA » va changer et prendre celle de « cpt » sur Serveur.

 

 

3 – Difficultés rencontrées

 

Tout au long de ce projet, nous avons rencontrés toutes sortes de difficultés. Mais le plus important, c’est de savoir garder patience pour les surmonter.

L’un des points négatifs du logiciel Automation Studio est qu’il n’indique que peu souvent les erreurs. Une petite erreur dans la configuration des variables et vous pouvez en avoir pour des heures jusqu’à à la découverte du problème. Il faut chercher le plus souvent soi-même les erreurs qui font que la visualisation ne fonctionne pas par exemple.

Il faut donc faire attention au choix des types des variables, de bien configurer les ports des CPUs, d’activer les variables selon le besoin ou encore de choisir les bons boutons pour la visualisation finale !

 

Conclusion

 

En somme, ce projet fut très intéressant car il s’agissait d’une nouvelle fonctionnalité que nous devions nous approprier afin de l’expliquer sous une forme didactique.

Nous avons donc joué à la fois les rôles de professeur, de programmeurs et d’étudiants de GEII. Malgré les heures de frustration lorsque nous avions des erreurs et que nous devions chercher une petite erreur, nous avons pris du plaisir à travailler sur ce projet.

La communication OPC-UA est une communication fiable, sécurisé et rapide. De ce fait, nous comprenons l’intérêt des grandes entreprises à l’acquérir car elle peut être extrêmement utile en plus d’être avantageuse.
Il s’agit d’une fonctionnalité encore assez récente, nous ne doutons pas que des améliorations futures rendront le travail des techniciens et ingénieurs travaillant dessus plus facile.

 

 

 

 

 


Mesure des signaux électrique par un Bitscope et un Raspberry DRIEUX _PEKA

                                                                                                                                                                    Logo-GEii-mulhouse

Sommaire

  • Introduction et définitions

  • Objectifs

  • Cahier des charges

  • Matériels et softwares

  • Assemblage des différentes pièces de la Raspberry et Bitscope

  • Programmation

  • Compilation cross-platform et fonctionnement des programmes

  • Oscillateur Bitscope
  •  Problèmes rencontrés

  • Support de Raspberry
  • Les points instructifs

  • Conclusion

 

 

Introduction

Dans le cadre de notre 2ème année, nous devons réaliser un projet en étude et réalisation.

Pour cela, nous avons choisi le projet de Mesure de signaux via une Raspberry et un Bitscope. Comme son nom l’indique, nous chercherons à mesurer les signaux électriques dans n’importe quel système et réseau du monde. Pour arriver à ce résultat, nous utiliserons une Raspberry et un Bitscope. La présence de la Raspberry permettra la gestions des données reçus par le bitscope lorsque celui-ci recevra les mesures de tension et d’intensité. Une fois en possession des données, nous les stockerons en temps réel et nous les afficherons sur l’écran de la Raspberry.

Raspberry : Circuit imprimé fonctionnant comme un micro-ordinateur

Bitscope : Circuit imprimé représentant un micro-oscillateur qui inclut  a la fois un analyseur de protocole logique puissant , un analyseur de spectre et un enregisteur de donnees .

Objectifs

  • Comprendre les différentes fonctions d’une Raspberry

  • Comprendre ce qu’est un Bitscope et son fonctionnement

  • Réaliser un programme adapter au cahier des charges du projet

 

Cahier des charges

Aujourd’hui, l’électricité est l’énergie principale utilisé dans le monde. Nous savons la calculer avec les formules de base comme la loi d’ohm. Ainsi, on a pu découvrir la présence des harmoniques dans les lignes électriques. Celle-ci augmentent la consommation de chacun, et les mesurées permettrait une grosse économie d’énergie.

L’objectif de ce projet est de mettre en place un système de mesure et de traitement des données de consommation énergétique.

Diagrammes fonctionnels :

Bête à cornes

Matériels et Softwares

Matériel

matériels

Software

-Éclipse : logiciel de programmation permettant de faire de la compilation croisée.

-Code Blocks : logiciel de programmation qui nous sert à tester le programme sur notre propre ordinateur.

-Bitscope software : logiciel constructeur permettant de gérer le Bitscope.

-Creo: logiciel permettant de faire le support du raspberry .

Assemblage des différentes pièces de la Raspberry et Bitscope

Assemblage écran LCD et Raspberry :

Assemblage Raspberry et Bitscope : la Raspberry et le Bitscope sont simplement relié par un cable USB.

Bitscope 1 Bitscope 2

Programmation

Pour la programmation, nous devons utiliser le programme fournit par le constructeur et le modifier de façon à ce qu’il fonctionne de la manière que l’on souhaite.

Voici le programme constructeur :

Prog_constructeur

Prog_constructeur2

Compilation cross-platform et fonctionnement des programmes

Le compilation croisée est une sorte de compilation qui permet de compiler un programme sur son ordinateur en fonction d’une autre machine reliée au PC (une Raspberry par exemple). Cette compilation croisée permettra donc de résoudre les problèmes de vitesse de compilation en utilisant directement son propre pc.

Le fonctionnement du programme est le suivant :

Il y a 5 étapes: l’initialisation, le setup, le tracé, l’acquisition et la fermeture.

Tout d’abord, le programme la library s’initialise et les périphériques doivent être en fonction. Avant de lancer un tracé, les périphériques doivent être installés. Dès que les tracés sont prêts, les données peuvent être acquissent sur l’ordinateur hôte pour les affichées et les analysées. Une fois terminé, les périphériques sont stoppées.

Pour d’informations, voici le guide constructeur du programme:  http://www.bitscope.com/software/library/guide/2.0/

Etant donné que la compilation cross-plateforme et que le programme constructeur nous envoie une erreur lors d’une compilation normal, nous avons dû trouver une solution afin de tout de même exploité les données du bitscope.

Pour cela, nous avons utilisé la fonction « save » du logiciel constructeur pour avoir la possibilité de récolté les données en temps réel et les stockées dans un fichier .csv.

Fichier .csv : document texte-like contenant une plage de données séparée par des virgules / points-virgules.

Capture projet

 

Afin d’ouvrir ce fichier .csv,  trier ses données et en faire un graphique, nous avons utilisé le logiciel Excel avec sa fonction d’importation de fichier spéciaux tel que .txt et .csv. Avec ses paramètres avancés, les données sont triées dans un tableau.

Nous avons fait plusieurs captures et nous avons remarqué que le nombre de mesure par seconde était différent entre les diverses captures. On a donc refait une mesure en gardant les calibres stables tout le long de celle-ci.

Après avoir importé les données sous forme de tableau, nous avons cherché un moyen de transformer toutes ces données en graphique. Pour cela, nous avons utilisé une formule pour convertir les lignes de données en colonne de donnée et mettre ces colonnes à la suite.

Capture PROJET 3:  permet de mettre toutes les données dans une seule colonne et dans l’ordre .

Capture Projet 5: donne le numéro de colonne à laquelle correspond chaque donnée

Capture projet 6: donne le numéro de ligne correspondant à chaque donnée

Au final, si on assemble les numéros de colonne et de ligne de chaque donnée, on retrouve son emplacement dans le fichier .csv.

On a ensuite pu créer un graphique grâce au tri des données. On a rencontré quelques soucis avec celui-ci, car il n’a pas la forme que sur le logiciel constructeur. Dans l’oscillation du signal, il nous manque une/deux oscillation. L’autre souci est aussi que les valeurs des données sont trop petites.Capture projet 2

Pour résoudre ce problème de valeurs, nous avons contacté le constructeur afin de savoir si l’on pouvait avoir le code source du logiciel. Cependant, il ne pouvait pas nous le fournir. Nous avons aussi remarqué qu’il y avait un facteur de multiplication/division de 12.

                                                                    Oscillateur Bitscope

Le Bitscope support une valeur de tension entre -+12 V .

Signal bruité

16144800_1841374596105739_385241887_n (1)

Signal du courant

16144179_1841374599439072_1902002774_n

 

 

                                                                   Support de Raspberry

Pour facilite l’utilisation de  notre  raspberry , on a  réalisé  un support pour le raspberry  comme projet en Mécatronique . Premièrement on a étudié  les mesures nécessaires et ensuite on a commencé  la conception des pièces . Le support contient trois pièces : deux bras et le support .

        Le bras

bras (1)

Le support

Support

L’assemblage

Assemblage

Le logiciel utilise pour créer  cet assemblage est Creo . Les deux bras seront conçus avec une  découpeuse jet d’eau et le support serait fait à l’aide d’un imprimante  3D.

Problèmes rencontrés

-Problèmes de compilation du programme constructeur sur Code-Blocks.

Problèmes de Library

Problèmes  de lancement d’application

 

probleme

-Problèmes de installation de logiciel de Bitscope sur le Raspberry

-Difficultés de configuration du logiciel Éclipse.

-Problème de compilateur

Problème de la taille des données captures par le logiciel Bitscope

 

Les points instructifs

-Fonctionnement du logiciel Éclipse

-Fonctionnement du système d’exploitation Raspbian (Linux)

-Programmer en cross-platform

-Configurer le Raspberry de manière à ce qu’il communique avec un ordinateur

Conclusion

Malgré les difficultés rencontrées, nous avons tout de même avancé dans notre projet. Au départ, nous devions comprendre comment câbler/relier les différents composants tel que la Raspberry avec l’écran LCD et le Bitscope avec la Raspberry. Nous devions aussi réussir à câbler un capteur de courant au bitscope, ce qui nous a permis de capturer un signal d’une alimentation et d’une lampe. Pour réaliser tout ca,  nous avons tout d’abord tenter de modifier le programme du constructeur de Bitscope, pour pouvoir par exemple utilisé des paramètres d’échantillonnage plus poussés. Cependant, après une erreur du programme difficile à corriger, nous avons utiliser le logiciel constructeur permettant  ainsi de voir directement les signaux au dépit de paramètre personnalisable et de les sauvegarde en temps réelle.  Apres avoir  exporté  les données sous un fichier .csv, nous avons pu exploité ce format grâce à excel et ensuite créer un graphique à partir de la plage de données.

Pour finir, nous avons pu obtenir un graphique convenable mais encore avec quelques erreurs.


Mise en œuvre du JANITZA pour l’analyse de la qualité de l’énergie

iutCouleurlogo-uha

LogoGEii2

 

Mise en œuvre du JANITZA® pour l’analyse

de la qualité de l’énergie

 

 

I) Cahier des charges:


But du projet:

 

Ce projet a pour but de permettre à des techniciens ou autres personnes d’avoir les informations nécessaires pour connaître la qualité de l’énergie présents dans une installation. Il serait donc intéressant de pouvoir  accéder en direct à ces informations mais aussi aux mesures précédentes afin de mieux comprendre le fonctionnement et les éventuels défaut d’une installation.

 Solution:

 

Afin de répondre aux mieux à cette problématique nous avons utilisé un JANITZA® UMG 96 RM-E équipé de transformateurs permettant de faire les mesures. De plus nous avons choisi de créer une base de donnés permettant de stocker toute ces mesures afin d’y avoir accès en temps voulu.

 

 

Bête à cornes:

Capture


 

II) MATERIEL UTILISE:

 

1) Le JANITZA® UMG RM-E et ses capteurs de courants


LE JANITZA:

 

Le JANITZA® UMG RM-E est un analyseur de puissance avec mesure du courant différentiel. Il est possible de l’équiper de transformateurs de courants et de tensions permettant différentes mesures ( courant et tension des différentes phases, taux de distorsion harmonique, puissance, valeurs moyennes des courants et tensions…). Ce module propose plusieurs options de communication (Modbus, TCP/IP, HTTP, FTP…). De plus il est équipé d’interfaces éthernets, RS485, d’entrés/sorties numériques et analogiques.  On peut visualiser les mesures via des graphiques grâce au logiciel GridVis. Il est également possible de retrouver ces mesures sur une page internet grâce au serveur de l’appareil.

janitzaJanitza arriere

logo janitza

 

 

SOURCE: www.janitza.com
Transformateur de courant 

Ces transformateurs de courant sont très pratiques du fait de leur simple intégration dans différentes installations. Il est possible d’installer ces transformateurs sans interrompre le process d’une installation. En plus de leur praticité ces équipements sont fiable et très précis dans leur mesures. Ils transmettent le courant nominal à l’extrémité du câble au secondaire.

 

 

transformateur wago

 

 

Wago-logo

 

 

 

 

 

 

 

 

SOURCE: http://www.wago.fr/media/france/prsentation_ti_ouvrants_855_fr_en.pdf

 

 

2) RASPBERRY et serveur web

 

Dans notre cas nous avons utilisé une Raspberry pi 3 model B. Une Raspberry Pi  est un nano-ordinateur monocarte qui possède son propre système d’exploitation sous linux. On peut naviguer sur internet, développer des programmes  et gérer des sorties.

Raspberry (1)RPi_LOGO_TEXT_REG_RGB

 

Cette Raspberry va nous permettre d’héberger le serveur nous permettant de stocker la base de données. En effet, cette solution est la plus pratique et la plus économique, en choisissant la Raspberry nous avons la possibilité de modifier nos services a souhait (taille du disque, hébergement de database…).

3)Base de données

 

Une fois le serveur prêt nous avons crée une base de données. Nous avons mis en place un  SGBD ( système de gestion de base de données ) , MySQL puissant SGBD et très répandu.

MySQL.svg

 

 

III) Réalisation

 

1)Préparation et configuration du JANITZA® UMG 96 RM-E

 

 Cet appareil n’étant pas livré avec un câble d’alimentation, nous avons dû débuter ce projet par la fabrication de ce câble à partir de celui d’un autre appareil.  Pour se faire nous avons rajouter un fusible de calibre 1 A.

fusible

fusible 2

 

Ce fusible aura pour but de protéger le JANITZA. Une fois fait, le JANITZA peut être alimenté et est opérationnel. Il est donc nécessaire de le configurer de manière à pouvoir communiquer avec un ordinateur afin de visualiser les mesures via une page internet ou le logiciel GridVis®.

Il est donc indispensable de mettre en place une IP sur le même réseau que l’ordinateur utilisé pour communiquer. Dans notre cas nous utilisons un câble RJ45 et les interfaces ethernet.

schéma

Pour configurer l’appareil il faut passer en mode programmation et rentré l’adresse IP manuellement (169.254.0.88 dans notre cas), ainsi que le masque de sous réseau (255.255.0.0)

config adresse

 

lorsque la liaison est en marche il est possible d’utiliser GridVis® et la page internet du JANITZA. Nous pourrons ainsi récupérer les mesures des capteurs.

PAGE INTERNET                                                           page internet              GridVis®

gridvis

 

 Nous n’avons aucune mesure étant donné que les courant pouvant être mesuré dans notre salle ( alimentation ordinateur, raspberry…)  sont trop faible. En revanche nous avons essayé et testé le fonctionnement des capteurs en prenant un soudeur ( plus grande consommation énergétique) et faisant des boucles.

2)Raspberry Pi et serveur

 

  Afin de récolter les données nous nous sommes servis d’une Raspberry Pi 3, Modéle B. Tout d’abord il a fallut la configurer. Après l’avoir mis à jour via son invité de commandes, nous avons du lui donnée une adress IP statique pour qu’elle puisse communiquer avec d’autres appareils(dans notre cas avec un ordinateur puis avec le Janitza). Son adresse IP est désormais 169.254.0.2.

    Nous avons ensuite résolu le problème du WiFi. En effet nous n’arrivions pas à nous connecter sur internet, nous avons donc installé un écran afin de facilité la configuration de la Raspberry Pi. Pour connecté l’écran, nous nous sommes servis des pins 2 et 6 du GPIO ainsi que du port Display. L’écran installé, il ne nous resta plus qu’à cliquer sur l’icone du Wifi apparue en haut à droite de l’écran puis de lancer le navigateur pour arriver sur l’écran de connexion. Une fois les identifiants rentrés, la Raspberry Pi sera connecté à Internet.

  Nous avons alors pu installer les logiciels nécessaire à notre projet:

apache2_logo

 

Apache est un logiciel qui va ici nous servir de serveur HTTP.

 

 

 

MySQL.svg

 

MySQL est un un système de gestion de base de données.

 

 

phpmyadmin-logo-gigante-quadrado.400.400.s

 

 

PHPMyAdmin est un logiciel optionel qui va nous permettre d’avoir une interface simplifiée pour MySQL.

 

 

Après plusieurs semaines passées, nous ne sommes pas parvenu à enregistrer les données mesurées par le Janitza. Nous n’avons pas réussi à exploiter les données via la sortie Ethernet de la Raspberry Pi. En effet le logiciel GridVis, ayant déjà la particularité de capturer des mesures, une protection à probablement été faite par la marque pour éviter la création d’un logiciel tiers.

 

3)Analyse de trame ethernet

Wireshark_logo

 

Une autre méthode que nous avons utilisé est l’analyse de trame Ethernet. Pour cela, nous avons branché le Janitza à un ordinateur portable où Wireshark était déjà installé via un câble Ethernet. Wireshark est l’analyseur de protocole réseau plus utilisé au monde. Il nous permet de voir les échanges qui se font entre l’ordinateur et le Janitza, nous pouvons ainsi voir toutes les données émises et reçues par chacun des deux appareils.

 

Les trames sont en hexadécimal et seule une partie de cette trame retranscrit les données que nous désirons avoir. Le problème que nous avons rencontré était que ce logiciel ne permet pas d’enregistrer les captures qu’il fait, nous n’avons donc pas pu nous servir de Wireshark pour traduire ces données en temps réels et les stocker par la suite sur une base de données externe.

4)Interface REST

 

Actuellement nous essayons de récolter des données via l’interface REST. Cette interface servirait à voir le dialogue entre le Janitza et l’ordinateur, toujours branché en Ethernet. Pour y accéder il faut taper l’url suivant: « http://169.254.0.88/data/records », une fois que le Janitza est complètement allumé. Pour n’afficher que la mesure désirée, il faut entrer: « http://169.254.0.88/data/records/<Variable-Name>;<Modbus-Address> ».

 

 

Quentin CERNO et Lucas FARICELLI


Gestion de la consommation énergétique d’une maison

iutCouleur

Projet :

Gestion de la consommation d’énergie d’une maison

Capture

BOULBAIR Badr/ DIENG Samba

SOMMAIRE :

  • Présentation du projet

  • Cahier des charges

  • Ressources

  • Réalisation du projet

  • Perspectives d’améliorations

  • Bilan/Conclusion


I) Présentation du projet

Tous les étudiants du GEII, en première année sont confronté à un challenge au cours de leur troisième semestre. Ils sont tenus de choisir un projet. Celui-ci doit être en lien avec le génie électrique, et plus précisément en adéquation avec l’option choisis en deuxième année. Dans notre cas il s’agit de l’option énergie renouvelable, et du projet intitulé : Gestion de la consommation d’énergie d’une maison. Nous devons réaliser ce projet dans le cadre du module « Études & Réalisations », dont la notation comprend plusieurs facteurs, bien entendu la réalisation du projet, la présentation de celui-ci (site web, video, powerpoint…), l’implication des différents membres, ainsi que le résultat final.

Le projet sera mené par Samba DIENG, ainsi que BOULBAIR Badr. Bien entendu avec le soutien des différents professeurs auxquels nous avons fait appel pour nous venir en aide, en particulier Mr. Djafar OULD ABDESLAM, et Mr. Mahfoud DROUAZ.

Dans l’UE1, un module est consacré aux énergies renouvelables. Ce module est composé de plusieurs matières, qui ont toutes été source d’inspiration, mais les matières suivantes ont eu un impact direct sur le projet : éolien, solaire, et smart grid. L’association de ces trois matières accompagnées d’une longue réflexion, nous ont mené à créer une maison autonome en énergie. Pour cela, nous avons commencé par créer notre maison, puis lui offrir les sources d’énergies suivantes : deux éoliennes, ainsi qu’un panneau solaire. Notre maison sera commandée par un Arduino que nous vous présenterons plus tard. Cet Arduino va en fonction de la production et de la consommation de la maison prendre différentes décisions, pour manager au mieux l’énergie. Avec notre maison il y aura une voiture électrique, qui est donc à même de se comporter comme une source d’énergie électrique, ou au contraire comme un appareil ménager à part entière qui doit être rechargé. Il y a trois grandes situations par lesquelles la maison passera :
-1er Cas, le cas favorable: La production des énergies renouvelables est supérieure à la consommation des appareils électriques de la maison, dans ce cas l’Arduino va diriger le surplus d’énergie vers la batterie de la voiture. Dans le cas ou la batterie de la voiture est déjà chargée, le surplus sera revendu à EDF.
-2eme cas, le cas neutre:  Ce cas correspond à une production d’énergie tout juste suffisante à la consommation de la maison.
3eme cas, le cas défavorable:  Içi la production d’énergie est inférieure à la consommation de la maison, dans ce cas l’Arduino va ordonner à la batterie de la voiture de se comporter comme une source d’énergie supplémentaire. Si par malchance la batterie serait déchargée, la dernière alternative sera de consommer l’énergie fournie par EDF.

II) Cahier des charges:

maillard

 

 

A) Expression du besoin
Diagramme bête à corne : c’est un outil de représentation de questions fondamentales. (A qui rend-il service, sur quoi agit-il, dans quel but).Sans titre214

B) Fonctions et Contraintes
Diagramme pieuvre :  Le diagramme pieuvre (ou APTE) nous permet de répertorier toutes les fonctions de notre produit. En effet nous rappelons que lors de la conception, les techniciens chercheront pour chaque fonction à satisfaire, la meilleure solution. Et c’est l’ensemble des solutions qui donnera le produit final.
pieuvre

FP1: Gestion de la consommation en fonction de la production d’énergie électrique de la maison
FP2: Faire en sorte que la proportion d’énergie produite gaspiller sois la plus petite possible
FC1: Le budget, une centaine d’euro prévu en fonction de l’ampleur du projet.
FC2: Reproduire les charges existantes dans une vraie maison à l’échelle de la maquette.
FC3: Le temps, 60h au semestre 3, et 45h au semestre 4.
FC4: L’esthétique, la maison doit être fidèle a une vraie maison.
FC5:  La production d’énergie renouvelables en intérieur (maquette pas prévu pour l’extérieur).

III) Ressources

A)L’Arduino Yun

1498-00

L’Arduino Yun est un microcontrôleur  basé sur le processeur ATMEGA32U4 et un processeur additionnel Atheros AR9331, sur lequel tourne la distribution Linux OpenWrt wireless stack. Il est également composé de composants complémentaires qui facilitent la programmation et l’interfaçage avec d’autres circuits.Il possède  un régulateur linéaire 5 V et 3,3V. Le module possède un port USB, et est programmé avec une liaison série TTL. C’est via cet Arduino que nous avons fait la gestion de l’énergie.

 

 

 

B)L’écran LCD

LCD

Cet écran va nous permettre d’afficher notre consommation, ainsi que notre production en temps réel. Le nom des broches et leurs utilités nous sont données sur l’image. Pour cela il va simplement falloir brancher l’Arduino à l’écran, et écrire un programme pour mesurer les consommations et productions. sur l’image ci-après on voit le schéma électrique contenant l’arduino et l’écran.

LCD_Base_bb_Schem

C) Les composants électriques pour gérer l’énergie.

LEDs-2-fiche

Les LEDs, utilisé à leur juste valeur elle
représenterons, l’éclairage de la maison.

800px-3_Resistors

Les résistances, elles aurons pour but de dissiper l’énergie,
qui dit dissipation dit échauffement du composant. c’est cet
échauffement qui synthétisera le chauffage de la maison.

 

sku_285973_1

 

Les relais: Ces composants seront placés à certains endroits
bien précis du circuit. Ils vont commander chacun une charge
(chauffage, éclairage, cuisine etc…)

 

LMZ14203

 

Le régulateur de tension LMZ14203, qui va ajuster
la tension d’entrée a la tension nominale des relais..

 

 

 

 

 

IV) Réalisation du projet

A) La maison


Nous avons commencé par le support le plus important du projet, il s’agit de la maison. Pour cela nous avons sur les conseils des professeurs, chercher des plan pour maison en 2D sur internet. Après quelques recherches, nous avons trouvé les plans de la maison actuelle. Nous avons utilisé la découpeuse laser dans le FabLab de l’IUT, pour créer notre maison, puis nous l’avons assemblée.

 

Le plan de la maison trouver sur internet :

c53cf2bd3a4ba337aec0ad3ef33680a3_preview_featured

Le matériau utilisé pour construire la maison:

panneaux-bois-5556468

Découpeuse laser, avec laquelle nous avons
couper les planches de bases:

legend-helix-24-front
Résultat après assemblage de la maison:a2c0267bb3c1f7ca3a0a52a9fd0a6d5a_preview_featured

B) Les charges

Ceci étant fait nous sommes passés au gros du travail, c’est-à-dire l’établissement des solutions électriques de notre maison et des différentes charges de celle-ci. Nous voulions dans un premier temps placé des LEDs associé à des résistances, pour que la consommation dans chaque branche du circuit soit différente. Mais pendant le bilan des puissances, nous nous sommes rendu compte qu’il serait plus judicieux et plus réaliste de synthétisé des appareils électrique de quotidiens avec des composants électrique de base à disposition. Par exemples nous avons la simulé la voiture électrique par une simple batterie, l’éclairage de la maison sera simulé par les LEDs, le chauffage sera simulé par des résistances, et pour les charges restantes nous sommes encore en train de réfléchir lesquelles choisir. Les charges étant plus ou moins définie, il nous fallait maintenant de quoi les alimentés.

C) La production d’énergie

L’alimentation de la maison sera divisée en plusieurs parties, les éoliennes, le panneau solaire, ainsi que la batterie de la voiture électrique qui sera un générateur en fonction de la situation, et il y a quand même pour le cas le plus défavorable une part reliée à EDF. N’ayant pas trouvé de génératrice adéquates à nos éoliennes nous avons décidé de simulé la production de leurs énergie, et de les faire tourner avec des moteurs. Le panneau ayant des dimensions un peu plus grandes que notre maquette il produirais assez à lui tout seul (220V). C’est pour cette raison que nous diminuerons volontairement sa production. La batterie fournira 12V/1,2Ah (sauf dans le cas ou elle doit être rechargée). EDF sera simplement un générateur à part, qui compensera l’énergie manquante.

Voici le panneau solaire:                                                                                                                                                                                                                                                                                                                                                                                                                                                   Les deux éoliennes:

Captureftg

Capturftie

 

 

 

 

 

 

D) Management de l’énergie via l’Arduino

      Maintenant que nous avons la production d’énergie, les charges qui consommerons cette énergie, il va nous falloir mettre en œuvre des programmes sur l’Arduino et des composants qui vont se chargé de commander le tout.
Le premier programme sera le programme pour afficher la production et la consommation pour savoir dans quelle configuration nous nous situons. Pour pouvoir les affichés il faut bien entendu recueillir ces informations. Pour cela nous avons fait une première carte composée de deux capteurs de courants, deux capteur de tensions, la multiplication d’une mesure courant/tension nous donnera une consommation en watts (U X I = P). Les informations recueillit par les capteurs serons traiter par l’Arduino via un programme. Ces information sont prise a des endroits bien précis du circuit.
Le deuxième programme sera le programme de commande des relais, ceux-ci vont laisser passé ou bloquer le courant qui passera dans une branche. Ces décisions seront prises par l’arduino, en fonction de la configuration dans laquelle on se trouve (voir les trois cas cités dans l’introduction).

E) Réalisations concrètes

1) Câblage des charges : Toutes les charges sont branchés en parallèle l’une par rapport a l’autre, ce choix a été fait pour éviter que si une des charges venaient à être court-circuitée, le reste du montage soit intacte. toutes les charges ont été divisées en plusieurs compartiments, alimentés indépendamment les uns des autres (mais les alimentations viennent toutes de la même source.

 

2)Réalisation de la carte à relais : Cette carte aura un bornier par compartiment, aux quel sera relier un relais (interrupteur) commander électriquement via l’arduino pour faire varier la consommation (tous les relais ouverts=consommation nulle/tous les relais fermés= consommation max). La carte sera alimenter par une alimentation externe, car nous avons rencontrés des problèmes avec le panneau solaire qui ne relevaient pas de nos compétences. Se trouve également sur la carte une régulateur de tension, car nous envisageons d’alimenter le montage avec une tension plus élever que celle suporter par les charges, afin d’avoir une tension de référence globale.

relaislast

3) Programmation : Le programme a été conçu sur le logiciel Arduino, dans un langage très proche du C. Ce programme va donner les ordres au relais de s’ouvrir ou de se fermé en fonctions des situations décrient dans l’introduction (favorable, défavorable, juste suffisant). le programme est divisé en deux, la première partie vise à lire la production et la consommation, tandis que la seconde partie va faire en sorte ue l’Arduino prendra une désision en fonction de ce qu’il a lu dans la première partie du programme. En voici une petite partie :

Capture

V) Perspectives d’améliorations

  1. Il aurait été plus qu’intéressant de se munir de vrai génératrices pour les éoliennes, plutôt que de simuler l’énergie produite par celles-ci. De ce fait le bilan des puissances n’est fiable que partiellement.
  2. Les mesure de la consommation et de la production sont des mesures générales, autrement dis on mesure la consommation de toutes le charges simultanément, et  nous mesurons la productions de toutes le sources de production de la même manière. Pour gagner en précision il aurais été plus efficace de mettre en place une mesure par charge, ainsi que une mesure par centre de production.
  3. De l’amélioration précédente découle celle-ci, les mesures étant multipliées, il aurais été profitable de pouvoir toutes les visualiser. Pour ce faire nous aurions pu utiliser un écran plus sophistiqué avec un menu, pour pouvoir cibler les mesures a visualiser.

 

VI) Bilan/conclusion

Du point de vue organisation le projet s’est plus ou moins bien déroulé. En effet nous nous étions dirigés vers un tout autre projet, mais après étude de celui-ci, nous sommes rendu compte qu’il nétais pas viable. Après réflexion et étude du nouveau projet qui est celui que nous venons de vous présenter, nous avons pu améliorer l’organisation, partager le travail, et le découper en plusieurs parties bien distinctes. Néanmoins tout le travail n’a pas encore été effectué. Nous avons pu réaliser les différentes composantes du projet, mais nous n’avons pas pu les mettre en commun, et par conséquent voir un résultat final.
Ce projet à laissé libre-cours a notre imagination. Nous avons pu travailler en groupe et se coordonner, et même parfois s’appuyer sur les autres groupes qui avaient des parties en commun avec notre projet. Nous avons approfondis nos connaissances dans les matières concernant les énergies renouvelables, ainsi que l’électronique. Nous avons fait face à des problèmes techniques qui ont suscité cogitation et réflexion, afin de les résoudre. Sans oublier les professeurs Mr OULD-ABDESLAM, Mr DROUAZ, ainsi que Mr VIGNE, qui nous ont été d’une précieuse aide tout au long du projet. En conclusion les projets s’encre bien dans l’étude et la réalisation, il sont agréable, et permettent d’apprendre par la pratique, qui fait le lien entre les cours les travaux dirigés, et les travaux pratiques.

 


Testeur de charge de batterie pour l’estimation du SoC

Testeur de charge: 

lipo-capacite-de-batterie-testeur-moniteur-12v-v

Sommaire :

 

Introduction 

Gestion de projet 

Cahier des Charges 

Contexte 

Conception 

Adaptation de la tension 

Câblage de l’afficheur LCD 

Réalisation du premier prototype 

Programmation du microcontrôleur Arduino 

Prochaine étapes à effectuer 

 

 Introduction :

Dans le cadre de notre DUT GEII, il nous a été proposé de réaliser un BMS (battery management system) .Vu la complexité d’un BMS nous avons accordé avec notre professeur de réaliser dans un premier temps un testeur de charge de batterie. Nos missions pour ce projet sont donc de mesurer la charge d’une batterie lithium polymère et de l’afficher sur un écran LCD.

Gestion de projet :

  • Luigi chargé de la programmation du microcontrôleur et des câblages.
  • Ayoub chargé de la réalisation du circuit imprimé sur kikad.

Cahier des Charges :

Préambule :

  • Pas à pas, petit à petit, découvrons ce formidable objet qu’est l’Arduino. Peu onéreux, c’est l’outil dont nous avons rêvé pour réaliser notre projet.
  • Programmer c’est indiquer au contrôleur ce qu’il doit faire… C’est aussi expliquer, dans le programme même, sous forme de commentaires, ce que l’on souhaite faire afin de pouvoir comprendre, plus tard, comment on y arrive. Ce genre de «détail» facilitera la mise au point et les futures améliorations.
  • Dons le cadre de notre projet on va utiliser l’arduino pour réaliser un testeur de charge batterie.

Présentation :

  • Il peut être utile de savoir comment tester une batterie. Ce test vous renseigne sur son état de marche, son état de charge et aussi sur l’état des ses cellules.
  • Tester une batterie est ainsi indispensable avant d’envisager son remplacement. En effet, si le problème vient d’autre composant, le remplacement de la batterie peut être inutile.

Critères généraux :

  • Capable de mesuré en temps réelle la charge de batterie ,donc si il peut nous renseigner sur l’état de la batterie.
  • Affiché le pourcentage de charge sur un afficheur LCD.

Critères de fonctionnement :

  • La tension doit être abaissée à 4.8v ce qui fait la nécessité d’un pont diviseur.
  • L’arduino doit être relié à l’aide d’un câble USB pour à la fois alimenter et connecte l’aduino au logiciel.
  • Un afficheur LCD et nécessaire pour affiché tous les informations sur la batterie.

Critères techniques :

  • Prise en main du logiciel qui va nous permettre de programmer l’arduino pour réaliser un testeur de charge.
  • Câblage de l’afficheur LCD.
  • Maitrise des bases de l’électronique pour réaliser un pont diviseur de tension.

 

Bête à cornes :

 

ESY (1)

Pieuvre :

 

JY

 

Contexte :

Pour réaliser notre projet nous nécessitions de certains éléments indispensables. Le plus important une batterie, l’IUT de Mulhouse nous a mis à disposition une batterie lithium polymère de 7.4V et 2200mAh composée de deux cellules, ensuite un microcontrôleur Arduino qui va nous permettre la mesure de la charge de la batterie, puis d’un écran LCD pour afficher la charge et pour finir quelques résistances pour adapter les tensions.

arduinoafficheur-lcd-2x16-i2c-pour-arduinobatterie

 

Conception :

Adaptation de la tension :

edd

La première chose que nous avons effectuée est l’adaptation de la tension de la batterie afin de mesurer sa charge à l’aide de l’arduino car en effet il ne peut pas recevoir des tensions supérieures à 5V en entrée. Comme on peut voir ci-dessus nous avons réalisé un pont diviseur de tension pour adapter les 8.4V délivrer par la batterie quand elle charger a 100% à une tension de 4.8V. Nous avons réalisé ce pont diviseur à l’aide 4 résistances une première de 10KOhms et trois autres de 4.7, 1.5, et 1.2 KOhms.

Câblage de l’afficheur LCD :

ghjvg

Dans un second temps nous avons réalisé le câblage de l’afficheur LCD sur l’arduino. Comme on peut voir sur la photo ci-dessus  avec ce montage on a la possibilité de régler la luminosité de écran à l’aide du potentiomètre en haut à droite

Réalisation du premier prototype :

tyiiuy

Comme on peut voir ci-dessus nous avons assemblé l’arduino avec l’afficheur LCD et la batterie avec son pont diviseur. On peut distinguer la sortie du pont diviseur qui va se raccorder sur l’arduino, sur l’entrée analogique A0 et la masse de l’arduino.

 

Nous allons mesurer la charge de la batterie en fonction de la tension qu’elle délivre, en effet on peut facilement trouver la courbe de décharge en fonction de sa tension d’une batterie lithium polymère :

azezrcvbcb

Programmation du microcontrôleur Arduino :

 

c vbcv

Comme on peut voir la première chose qu’on fait est d’intégrer la bibliothèque liquidCrystal pour pouvoir utiliser l’afficheur LCD. Grosso modo notre programme consiste à tester à plusieurs reprises la valeur qui rentre dans A0. On a peu déterminé les valeurs à tester d’une manière très simple, comme on sait que l’arduino travail sur 10 bits et la tension maximale qu’il peut recevoir est de 5V donc on peut en déduire que si l’entré analogique A0 reçois 5V elle correspondra à 1023 dans l’arduino. On peut alors déduire les valeurs en bits qui correspondent aux différentes tensions à l’aide de la courbe de décharge présentée précédemment.

 

azrezt

On peut voir ci-dessus que notre premier programme fonctionne très bien et affiche la charge de la batterie en pourcentage à l’aide de tension en entrée sur A0.

Réalisation du circuit imprimé : 

Nous avons décider de réaliser un circuit imprimé pour éliminer tous les câbles et avoir un rendu beaucoup plus beau et professionnel. La realisation circuit imprimé c’est effectué a l’aide du logiciel Kicad.

fgh

Ci-dessus vous pouvez voir une capture d’écran d’un des premier prototype fait sur kicad, le fichier que vous voyez ci-dessus est un .pcb en effet lors de la réalisation d’un circuit imprimé sur kicad nous devons éditer plusieurs fichier comme par exemple le .ch ou encore la net liste.

Au final la réalisation de ce circuit  nous a permis d’éliminer tous les câbles pour l’afficheur LCD ainsi que le câblage du pont diviseur.

 20170329_201802-min20170329_201742 (1)-min

Comme vous pouvez ci-dessus le résultat final est très propre et bien plus professionnel.

 

Modification du programme :

Capture

Nous avons modifier le programme de manière a le rendre le plus simple et plus précis, maintenant on ne test plus la valeur en entrée sur la borne A0 de l’arduino mais on fait un simple calcul pour déterminer le pourcentage de charge de la batterie en fonction de la tension quel délivre. On peut faire ce calcul  a l’aide de certaines valeurs qu’on connait. On connait la tension maximale en entrée dans l’arduino donc on peux déterminer sa valeur en bite et dire quel correspond a la valeur de 100% de charge de la batterie, et donc réaliser un produit en croix pour déterminer  le pourcentage correspondant a la tension délivrer par la batterie.

 

Problème rencontré :

Tout d’abord nous avons eu un problème avec la batterie car ce model de batterie est défectueux. Du jour au lendemain la batterie ne fonctionnait plus elle délivrait plus aucune tension, donc dans un premier temps on pensait qu’elle était casser et que on devait adapter notre pont diviseur ainsi que le programme a une autre batterie,mais quand nous en avons parlé a un de nos professeur il nous a dit que ce problème est récurrent sur ce type de batterie, quand on l’utilise longtemps et de marnière intensive. En effet a l’intérieur il y a circuit de protection qui parfois ne fonctionne pas très bien et bloque la batterie et la rend donc inutilisable, mais qu’il suffit d’envoyer dans la batterie un signal de la bonne tension et du bon courant pour débloquer ce circuit.

20170329_214011-min

Ensuite nous avons eu un problème avec le chargeur car a chaque fois que on essayait de charger la batterie, le fameux circuit de protection intervenait et bloquait tout. En faite on ne c’était pas  rendu compte que les bornes + et – était inverser sur notre chargeur, ce qui est atypique pour ce type de chargeur. Donc nous avons couper et dénuder les fils pour les souder de manière a avoir les bornes comme on le désirait.

20170329_212326-min

Pour finir le dernier problème était un simple faux contact sur notre circuit imprimer qui nous a fait perdre pas mal de temps car on a du vérifier toutes les pistes par peur d’avoir commis une erreurs lors de la conception de celle-ci.

Bilan :

Donc ce projet nous a beaucoup plus car il regroupais plusieurs domaines, l’informatique et l’électronique. Il nous a permis de revoir nous formule et nos TP d’électronique avec le câblage de l’écran LCD  et la détermination des résistances dans le pont diviseurs. Il nous a aussi permis de découvrir l’arduino et son logiciel pour le programmer.

Idéalement on pourrait continuer ce projet pour mesurer la charge de plusieurs batterie en simultanée pour finalement gérée l’utilisation de chacune lorsque elle alimente quelque chose et donc réaliser un BMC.

 


Application mobile qui permet l’exploitation de données en temps réel d’une voiture



 titre

 

 


Présenté par : Antoine TOENZ et Valentin SUTTER

Ce projet a été réalisé dans le cadre de notre deuxième année de DUT GEII, dans l’enceinte de l’IUT de Mulhouse.


 sommaire


Présentation

De nos jours, une grande majorité des gens se plaignent du coût de leur voiture notamment concernant l’essence, la maintenance, l’assurance, l’obsolescence. Il y a des pressions concernant la pollution qui sont de plus en plus fortes et depuis quelques années l’électronique s’est installée dans nos voiture, ce qui fait qu’en cas de panne nous sommes un peu pris au dépourvu et il devient difficile de pouvoir gérer sa voiture soi-même. Notre projet va aider les conducteurs à pouvoir diagnostiquer et détecter les pannes, et également créer un suivi de trajet afin de pouvoir améliorer sa qualité de conduite.

betweentext

voiture

betweentext


betweentextObjectifs

Nous avons comme objectifs de créer une Application Mobile Android comprenant un outil permettant d’obtenir les informations émises par la voiture en temps réel, ainsi qu’un assistant intelligent, le tout codé en langage Java. Pour cela, il faudra brancher un outil appelé ELM327 à la prise diagnostique de la voiture, ainsi nous pourrons récupérer les données du véhicule par Bluetooth, et les exploiter dans notre application afin de guider l’utilisateur à opter pour une conduite plus souple en lui permettant de pouvoir suivre les données de son véhicule en temps réel. Ces données étaient pour le moment uniquement accessible aux professionnels, maintenant grâce à AmiGo, elles sont à portée de main.

betweentext

voiture

betweentext


betweentext

 Cahier des charges

                 différentsoutils

    outils2

 


betweentextExpression du besoinbetweentext

bête à corne

Cette bête à cornes nous permet d’obtenir plusieurs informations. En effet, grâce à elle, nous savons à qui rend service le produit (à l’utilisateur), sur quoi agit le produit (sur la conduite de l’utilisateur), également dans quel but le système existe (donner des indications en temps réel à propos du véhicule afin d’adopter une conduite économe).

betweentext


betweentext

diagramme pieuvre

explication pieuvre


Ressources

Voici les différentes ressources dont nous avons eut besoin durant ce projet :

Ressources ELM_USB

Documentations_ELM

Normes et protocoles OBD

ELM_Guide


 Développement

Tout d’abord nous devons définir le terme de ELM327, le schéma ci-dessous montre les différents ports de cet appareil. Nous pouvons remarquer que l’ELM327 comporte des ports CAN, ainsi que différents types de protocoles (ISO, J1850, etc..)

 ELM327 détails


betweentext

Afin de pouvoir récolter les données du véhicule, il faut brancher l’ELM327 à la prise diagnostique de votre véhicule (tout véhicule depuis l’année 2002 comporte une prise OBD mais son emplacement dépend des constructeurs), plus communément appelée prise OBD. (figure ci-dessous)

betweentextobd

betweentext


betweentext

Tout d’abord nous avons dû définir quel type d’ELM327 nous allons utiliser afin de récupérer les informations du véhicule. En effet, le choix a dû se faire entre trois différents appareils: l’ELM327 USB, Bluetooth et WiFi (figure ci-dessous).

betweentext

3obdbetweentext

Après plusieurs tests, nous avons remarqué que l’ELM327 Bluetooth serait le plus adapté (de par sa polyvalence et son accessibilité) pour notre projet.  En effet, le type USB pourrait gêner l’utilisateur pendant sa conduite (selon le câble et l’emplacement de la prise OBD dans son véhicule), et le type WiFi aurait demandé une maîtrise de plusieurs normes et la gestion de réseau, et cela n’est pas nécessaire dans le cadre de ce projet

betweentext


betweentext

Concernant l’application, nous avons décidé d’utiliser l’IDE nommé Android Studio. Le code de l’application va être divisé en plusieurs parties: tout ce qui est visible par l’utilisateur (User Interface) est regroupé dans un dossier  »res »  pour ressources qui comporte tout les layout et toutes les parties visibles (figure ci-dessous).

betweentext

graphbetweentext


betweentext

Par la suite, nous avons également la partie codage nommé  »java » qui va comporter toutes les variables dont nous avons besoin, et toute la logique de l’application. Cette partie est beaucoup plus dense que la précédente, en effet elle est divisée par plusieurs sous-parties qui dirige une action bien précise (figure ci-dessous).

betweentext

code


betweentext

La partie Interface de l’Utilisateur est très importante car l’utilisateur se souciera uniquement de ce qu’il voit. Il nous a fallut donc mettre un accent sur la partie esthétique de l’application. En effet nous avons souligner cet aspect par la création d’un logo spécifique à l’application (figure ci-dessous) , ainsi que dans les choix des couleurs des interfaces, des animations ludiques, pour le plaisir de l’utilisateur.

betweentext1000x1000

betweentext


betweentext

focntionnement

Nous avons mit en place un menu permettant de naviguer entre les différents onglets (figure ci-dessous) :

betweentext

menu

betweentext

En effet, plusieurs onglets sont à notre disposition, l’un d’entre eux, Analyse des données (fig.1), permet d’analyser sa consommation sur le long terme (possibilité d’importer et d’exporter des fichiers). Un autre onglet Réglages (fig.2), nous permet de choisir les différentes options souhaitées par exemple le protocole utilisé, la fréquence de mise à jour, connexion automatique ou   non, unité préférée, etc…

betweentext

                                                                  fig.1                                                                                                                                         fig.2

 analyse                                                  réglages

betweentext


betweentext

test

Après la phase de développement, nous avons effectué plusieurs phases de tests. Une fois l’ELM327 branché sur la prise diagnostique du véhicule, nous devons activer le Bluetooth sur l’appareil Android. Une fois cela fait, l’application détecte un nouveau véhicule entrant, et il ne suffit plus que de sélectionner les données que l’on veut visualiser .

betweentext

Pour les tests qui vont suivre nous les avons réaliser sur une Polo V (2012)betweentext

Lorsque la voiture est en route, on remarque que l’application récupère bien les données du véhicule (fig.3) et l’on peut sélectionner ce que l’on souhaite (fig.4)(Vitesse, température ambiante, pression barométrique, consommation, distance parcourue depuis l’utilisation de l’application, etc…)

betweentext

                                                                fig.3                                                                                                                                           fig.4

Amigo2                                                  AmiGo1

betweentext


betweentext

Voici une vidéo expliquant de manière simple l’ensemble de notre projet :

 

 

betweentext


betweentext

bilan

Pour conclure, ce projet nous a permis de découvrir de nouvelles choses comme: la gestion d’un projet, le travail en équipe, la démarche à suivre pour arriver au bout d’un projet, certaines nouvelles méthodes. De plus, cela nous a permis d’approfondir nos connaissances en informatique et en langage java, ainsi que la création d’une application mobile Android. Malgré les difficultés encourues, nous avons pu finir notre application, dans de bonnes conditions.

betweentext

finish

betweentext


betweentext

Vous avez donc peut être des mauvaises habitudes de conduites que vous ignorez…

Alors avec notre application, votre assistant de conduite AmiGo vous guidera pour aidez à vous corriger et à faire de vous un conducteur éco-responsable.

betweentext

     main

betweentext


 

 


Monture téléscope

 1   02

PROJET MONTURE TELESCOPE

 

MESSAOUDI Muhammed-Anis

GAECHTER Hugo

DREYER Loann

 

Sommaire

 

Introduction

Présentation du sujet

Cahier des Charges

Développement

Passer d’un Push-to à un Go-to

Perspectives d’évolution du projet

Gestion de projet

Bilan

Définitions à connaitre

Webographie

Remerciements

 


Introduction

 

NOMS

 

Nous sommes un groupe de 3 étudiants qui avons choisi en tant que projet de 2ème année DUT GEII de réaliser un programme capable d’assister un utilisateur de télescope dans le positionnement de sa monture. Nous avons travaillé pendant 2 semaines sur ce projet, de façon libre tout en aillant accès à l’aide de Mr. HAEBERLE si besoin.

 

⇑Sommaire

 


Présentation du Sujet

 

L’utilisateur devra choisir via un clavier l’étoile qu’il cherche à observer, puis la date, l’heure et le lieu dans lequel il se trouve pour permettre au programme d’afficher via un écran LCD les instructions nécessaires au réglages du télescope, à savoir les degrés d’inclinaisons sur le plan vertical et horizontal. Nous équipons la monture de verniers afin de pouvoir placer ces 2 axes aux bonnes valeurs, manuellement.

Dans un second temps, nous pourront transformer ce système appelé « push-to » (c’est à dire que le système nous fournit les coordonnées mais nous devons déplacer manuellement la monture du télescope) en un système dit « go-to », en ajoutant sur la monture des moteurs commandés par le programme. Ainsi, l’utilisateur n’aura plus qu’à choisir l’étoile qu’il souhaite observer. La date, l’heure et le lieu seront récupérés via un module GPS, et la monture s’orientera d’elle même via les moteurs pour pointer l’étoile.

⇑Sommaire

 


Cahier des Charges

 

Cadre du projet :

 

Besoins :

  • Connaissances techniques à acquérir dans l’astronomie et Mplab
  • Une monture télescope sur laquelle travailler.

But :

  • Le but du projet est de rendre le pointage d’une étoile choisie plus simple pour l’utilisateur de notre monture télescope.
⇑Sommaire

 


Contraintes :

 

De connaissances :

Afin de réaliser le programme de notre projet, il est nécessaire d’avoir des notions de base en astronomie sans lesquelles nous ne pouvons pas comprendre le sens des calculs à effectuer.

 

Mouvements permanent des astres et de la Terre.

Les astres tout comme la Terre sont en permanence en train de se déplacer. Ainsi, aucun des repères des calculs n’est fixe et donc il faut savoir s’adapter.

 

⇑Sommaire

 


Réponses à ces contraintes:

 

Les contraintes de connaissance :

Nous nous sommes appuyés sur le rapport de stage final réalisé il y a plusieurs années (du 6 Mai au 10 Juin 2009) par un ancien étudiant GEII : BIEHLER Stéphane.

Son projet était le même que le notre, à la seule différence qu’il était seul pour le réaliser, mais l’a fait en plus d’un mois.

Ce rapport nous a aidés à comprendre les notions de base d’astronomie : la compréhension de la position et du déplacement d’un objet (une étoile, un astre) par rapport à la Terre et plus particulièrement par rapport à l’endroit où l’on se situe. Un objet est repéré par son ascension droite et sa déclinaison, qui se mesurent respectivement en Heure Minute Seconde, et en Degré Minute Seconde.

La contrainte de mouvements :

La Terre ne tourne pas sur elle-même en 24h exactement mais en 23h 56m 4.09s, ainsi une différence se creuse entre la position d’une étoile entre 2 journées pour une même heure. Pour cette raison, il nous faut passer sur un autre calendrier, le calendrier Julien. Le programme effectue la conversion, suite à quoi on pourra calculer le temps sidéral, car si on connait le temps sidéral et la position de l’observateur, ainsi que les coordonnées de référence de l’étoile à observer, on peut en ressortir l’azimut et l’altitude via les équations de Taki. Ce sont les 2 paramètres finaux que l’on cherche à avoir puisque avec ceux-là, on est capable d’orienter notre monture facilement dans la bonne direction.

⇑Sommaire

 


Objectifs :

 

L’objectif premier du projet est de créer un programme embarqué capable de donner à l’utilisateur des instructions simple (angle horizontal et vertical de sa monture) à mettre en place afin d’observer l’étoile souhaitée.

Il sera ensuite envisageable de réduire au maximum le rôle de l’observateur dans la mise en position de la monture de son télescope, tout d’abord en rajoutant un module GPS capable de récupérer le lieu, la date et l’heure. Ainsi, l’utilisateur n’a plus à rentrer ces paramètres, il n’a plus qu’à choisir l’étoile et ajuster manuellement sa monture.

La plus grande progression possible serait ensuite de transformer ce système push-to en un go-to, en ajoutant des moteurs sur la monture du télescope et des encodeurs sur les axes verticaux et horizontaux, afin que le système se rende automatiquement aux coordonnées d’azimut et d’altitude. Sur un tel système, l’utilisateur n’a plus qu’à sélectionner l’étoile qu’il désire observer. La monture dirigera d’elle même le télescope tel qu’on voit cette étoile en tout lieu, toute heure.

⇑Sommaire

 


Développement

 

Matériel utilisé :

Plaquette

Nous avons programmé sur ce type de plaquette (PIC18F4520). La lecture des coordonnées d’instructions pour orienter correctement la monture se liront sur l’écran LCD, et les informations saisies par l’utilisateur (Date, heure, choix de l’étoile) se feront via un clavier matriciel de ce type raccordé à la plaquette :

 

Clavier matriciel

⇑Sommaire

 


Explications du programme :

 

1.1 L’initialisation

Tout d’abord, il faut définir :

    • La date
    • L’heure
    • L’étoile qu’on souhaite pointer :

Exemple : Coordonnées de Polar

Déclinaison : 89° 16' 0''
Ascension : 2 heures 31 minutes 48 secondes
    • L’endroit où on se situe avec la latitude et la longitude en degré minute d’arc(‘) seconde d’arc( »), qui sont des sous unité du degré :

Exemple : Mulhouse

Latitude : 47° 44' 58''
Longitude : 7° 20' 24''

1.2 Conversion grégorien julien

Notations :

J : jour du mois

M : Mois (janvier M=1, fevrier M=2…)

A : Année

Ent[] : Partie entière de l’expression entre crochets.

Si M=1 ou M=2, on remplace A par A-1 et M par M+12 car janvier et février sont en fait les mois 13 et 14 de l’année précédente.

On calcule :

C=Ent[A/100]

B=2-C+Ent[C/4]

Car la date est une date de calendrier grégorien.

Ensuite on calcule la fraction du jour :

On sait que dans 1 jour il y a 24h , qu’il y a 60 minutes dans 1 heure donc 60*24=1440 puis 60 secondes dans 1 min donc 60*60*24=86400

T=(Heure/24)+(minutes/1440)+(secondes/86400)

Puis avec les calculs qu’on a fait précédemment on peut calculer le jour julien qui est donné par la relation suivante :

JJ = Ent[365,25*(A+4716)] + Ent[30,6001*(M+1)] + J + T + B -1524,5 ;

Remarque : Lorsqu’on passera pour l’affichage des écran LCD on séparera la partie entière et la partie décimal.

Après avoir réussi à calculer le calendrier julien , on va pouvoir passer au temps sidéral.

 

1.3 Temps sidéral

Le temps sidéral sert à éviter un décalage dans le temps car la terre tourne autour du soleil pas en 24h mais en 23h56m4,09s.

Notation :

JJ=Jour julien.

Il faudra calculer le TSMH (temps sidéral) qui sera donné en heure dans cette formule :

TSMH = 18.697374558+(24.06570982441908*((JJ-2451545))

On fait le jour julien -2451545 car le jour julien débute le 01/01/2000 à 12h ce qui correspond à la valeur 2451545.

Lorsqu’on aura calculer le temps sidéral en heure, il faudra ensuite convertir ce résultat en heures minutes secondes.

 

Pour avoir les heures :

heure=(TSMH/24)

floor : correspond à la partie entière de l’heure

TSMH=heure-floor (heure)

TSMH=TSMH*24;

sidereal.h=floor(TSMH);

car 24 heures dans 1 jour.

 

Pour avoir les minutes :

TSMH=TSMH-floor(TSMH)

TSMH=TSMH*60

sidereal.h=floor(TSMH);

car 60 minutes dans 1 heure.

 

Pour avoir les secondes :

TSMH=TSMH-floor(TSMH)

TSMH=TSMH*60

sidereal.h=floor(TSMH);

car 60 secondes dans 1 minute.

 

1.4 Angle horaire

On va passer des coordonnées équatoriales (julien/temps sidéral) en coordonnées horaires (déclinaison /angle horaire).

L’angle horaire permettra par la suite d’avoir l’azimut et l’altitude.

Ce calcul est simplement la soustraction au temps sidéral à Greenwich de la longitude de l’observateur et de l’ascension droite de l’objet à pointer.

Angle horaire= Temps sidéral – Longitude – Ascension droite

 

Angle horaire

 

Rappel : On ne peut pas faire directement la soustraction, car degré minutes secondes différents d’heure minutes seconde.

Difficulté : Le plus dur dans cette étape est de réussir à convertir des heures minutes secondes, que sont l’ascension droite et le temps sidéral, en radians, et des degrés minutes secondes (longitude) en radians.

Pour réaliser cela on a fait appel à des fonctions pour convertir des degrés minutes secondes en radians, fonctions qu’on aura récupérées du programme de Biehler Stéphane.

 

1.5 Azimut et altitude.

Le passage de coordonnées horaire (déclinaison angle horaire) au coordonnées céleste (azimut altitude) se font par les équations de Taki.

Dans la première équation, Le, Me et Ne représentent des coordonnées intermédiaires.

H représente l’angle horaire préalablement calculé et δ représente la déclinaison de l’objet à pointer.

1

On multiplie ensuite la matrice obtenue par une matrice de cosinus et sinus pour obtenir de nouvelles coordonnées Lh, Mh, Nh qui vont servir au calcul de l’azimut et l’altitude.

2

Enfin, on utilise les coordonnées calculées précédemment pour obtenir l’azimut et l’altitude.

3

Une fois qu’on a l’altitude et l’azimut , on a juste à déplacer la monture de façon à bien placer la monture pour pouvoir par la suite regarder l’étoile que l’on souhaite.

 

Sur le PIC18f4520 :

 

1. Initialisation

4

Il faut réaliser les calculs sur le PIC18f4520, pour cela il faut mettre les stacks à 256 car on a des variables doubles (float) et réaliser des calculs si conséquents demande beaucoup de mémoire.

 

2. Conversion grégorien julien

Lorsqu’on a réalisé dans la première partie la conversion grégorien julien, il faut séparer pour la valeur final les entiers et les décimaux.

Voici les lignes de codes à modifier:

5

 

3. Utilisation de l’affichage LCD

Pour l’afficheur LCD, il faut utiliser la bibliothèque printlcd.

On y retrouve une fonction permettant d’écrire le contenu :

ECRIT_CHAINE_d( » A vaut : %d !! « , a) ;

Et une autre qui permet de l’afficher :

AFFICHE_TEXTE(1)

Avec cet exemple, on écrit sur la première ligne avec une seule variable.

Si on veut écrire sur la deuxième ligne avec deux variables :

ECRIT_CHAINE_2d(A : %d et B : %d « , a, b) ;

AFFICHE_TEXTE(2) ;

Pour l’instant, Ecrit_CHAINE ne prend en compte qu’une valeur de 3 chiffres maximum.

⇑Sommaire

 


Réalisation des disques gradués sur la monture :

 

Disque azimutale avec son pointeur :

Pour obtenir des disques gradués de bonne dimensions, nous avons choisi de les dessiner nous-même via le logiciel CorelDraw afin de les réaliser via la découpeuse laser.

Nous avons commencé par dessiner le disque à placer sur l’axe azimutal, d’un diamètre de 32cm. Pour prendre en main le logiciel, nous avons d’abord copié une image de disque gradué existant que nous avons simplement étirée aux bonnes dimensions. Nous avons ensuite du améliorer ce disque en le perçant non plus juste au centre, mais aussi à des endroits bien précis pour laisser passer des vis (4 vis en tout, des trous de 1cm de diamètre). Une fois ces trous bien placés, le disque aux bonnes dimensions, nous nous sommes rendus compte que la précision des traits de l’image n’était pas satisfaisante. Ayant acquis une certaine expérience sur le logiciel, nous sommes maintenant capables de dessiner complètement le disque, en partant du centre pour tracer tout les traits de graduations des degrés (à partir d’une droite verticale, que l’on copie/colle en l’orientant à chaque fois d’un degré de plus que la précédente), ce que nous avons fait pour finalement imprimer la version finale.
Voici le disque gradué pour l’axe azimutal que nous avons réalisé:

Disque 1

Associé à ce disque, nous devons dessiner un pointeur afin de rendre le pointage plus précis. Pour se faire, nous avons du réfléchir à comment intégrer le pointeur sur la monture. Une fois la solution trouvée, nous l’avons dessiner puis imprimer au laser, comme pour le disque. Pour le pointeur nous avons dû palier au 2,5 cm de hauteur entre la base et le disque gradué. Nous avons coller entre elles 5 plaques de bois qui ont chacune 5 mm d’épaisseur qui épousait le disque tournant pour éviter que ça frotte lorsqu’on tourne le disque tournant.

Voici le pointeur que nous avons réalisé:

Rapport Monture

Rapporteur vertical avec son pointeur :

Même principe pour le disque de l’axe vertical, seulement c’est un demi-disque (90°), qui doit laisser passer des vis au niveau de son axe horizontal. Nous avons donc rajouter de la matière en bas à la manière d’un rapporteur, puis imprimer le disque au laser. Celui-ci étant plus petit, la solution de copier une image existante apporte une précision satisfaisante, il n’est pas nécessaire de redessiner complètement chaque trait pour chaque degré nous même.

oihzo
Pour le pointeur de l’axe vertical, il y a eu un obstacle : le support qui permet de mettre une deuxième lunette.
Pour palier ce problème nous avons du tout d’abord faire deux disque plus petit car sinon ça touche le support puis nous avons fais un troisième disque qui est un peu plus haut pour être à la taille du rapporteur puis pour être pile au même endroit que le rapporteur.
Pour cela, nous avons coller entre elles 4 plaques de bois qui ont chacune 5 mm d’épaisseur. Le pointeur épouse la forme du rapporteur pour éviter tout frottement entre elle et le rapporteur.
Le troisième disque, et le pointeur pour l’axe vertical :

pfojpzejfopzofjpezjfopz

 


Passer d’un Push-to à un Go-to

 

Pour passez du mode push-to au mode go-to, nous devons utiliser un moteur pas à pas.

Pour utiliser un moteur pas à pas il faut utiliser un driver pour permettre de piloter le moteur. On pourra choisir ensuite par le biais du driver sa vitesse de rotation et le nombre de pas que l’on souhaite.

AAAAA

Enable: Logique Inversée, permet d’activer ou désactivé le moteur. Etat Haut=High=Moteur actif… et axe bloqué entre les pas. Etat bas=Low=Axe totalement libre

  • M0, M1, M2: Permet de sélectionner la configuration Step/MicroStep. Ces broches disposent de résistances Pull-Down ramenant le potentiel à 0v lorsque rien n’est connecté sur ces broches.
  • Reset: Logique inversée. Permet de faire une réinitialisation du module. Généralement connecté sur la broche « sleep »,
  • Sleep: Logique inversée. Généralement connecté sur la broche « Reset » du module.
  • Step: Envoyer un signal d’horloge (Niveau Haut puis Niveau bas, High puis Low) pour avancer le moteur d’un pas.
  • DIR: Permet d’indiquer la direction de rotation du moteur. Etat Haut=High pour tourner dans un sens, Etat bas=Low pour tourner dans l’autre sens.
  • VMot: Tension d’alimentation. On a utiliser pour cela une alimentation de 12 volts et un courant de 1 A car une bobine fait 500mA et il y a deux bobines donc 1 A
  • GND: Sous « VMOT », masse pour l’alimentation du moteur.
  • A1 A2: Première bobine du moteur pas à pas bipolaire
  • B1 B2: Deuxième bobine du moteur pas à pas bipolaire (voir exemple ci-dessous)

 

Tous les câbles que vous allez brancher sur Step,DIR,M0,M1,M2 vont allez sur le port C ce qui va permettre ensuite de contrôler le driver.

Lorsque vous allez alimenter le PIC il faut utiliser une capacité de 46 µF pour protéger le driver et un radiateur pour éviter qu’il ne chauffe trop rapidement.

 

Pour les moteurs pas à pas, nous avons branché tout ce qui contrôlait le driver sur le port C.

Pour faire fonctionner le moteur pas à pas il faut juste faire un front montant sur le RC0 qui est le step dans les branchements.

PORTCbits.RC0 =PORTCbits.RC0 ^ 1;

Ensuite si vous voulez changer la résolution du moteur pas à pas et passez de 1/1 à 1/32.

Il faut modifier la valeur avec laquelle vous avez branchés le M0,M1,M2 dans la phase d’initialisation.

Résolution de 1 pas :

Vous devez mettre les ports M0,M1,M2 à 0

PORTCbits.RC3= 0;

PORTCbits.RC4= 0;

PORTCbits.RC5= 0;

Résolution de 1/36 pas :

Vous devez mettre les ports M0,M1,M2 à 1

PORTCbits.RC3= 1;

PORTCbits.RC4= 1;

Nous avons réussi à faire un moteur qui va d’une position x a y en fonction du pas et du sens
Pour cela nous avons tout d’abord initialiser :
Azi = 0; Position que l’on souhaite atteindre
PosAct = 270; Position initiale du pointeur
pas = 360.0/200.0; Pas de 1
Tout d’abord nous avons regarder si la valeur de Azi étais supérieure ou inférieure à la valeur que l’on souhaite pointer.

Puis en fonction de cela nous avons choisi soit de tourner dans le sens trigonométrique soit dans le sens inverse.

Par exemple avec cette phase d’initialisation :

if (PosAct > Azi)

{

if ( (PosAct – Azi) >=180.0 )

{

PORTCbits.RC1 = 1; // sens +

x=2*(360-(PosAct-Azi))/pas;

for (j=0; j < floor(x) ; j++ )

{

WaitEvent(ALARM_EVENT0);

ClearEvent(ALARM_EVENT0);

PORTCbits.RC0 = PORTCbits.RC0 ^ 1;//inversion RC0

if (PORTCbits.RC0==1)

{

i++;

if (PosAct ==360.0) /* !!! */

{

PosAct = 0.0;

}

PosAct = PosAct + pas;

}

}

}

Donc nous allons tourner dans le sens trigonométrique car c’est plus rapide d’allez de 270° a 0° en allant du sens trigonométrique car il ne faut que 90° pour qu’il atteigne cette position, contre 270° dans le sens des aiguilles d’une montre, ce qui est très conséquent pour le driver et le moteur pas à pas car il chauffe assez rapidement, pour ensuite le faire en fonction des calculs que nous avons réalisés auparavant avec l’altitude et l’azimut qui permet de pointer la monture là où on le souhaite.

Nous prenons la partie entière du calcul soit pour l’azimut soit pour l’altitude et nous la remplaçons par Azi qui est la position que l’on souhaite atteindre et cela va permettre de faire bouger le moteur du nombre de pas que l’on souhaite


Perspectives d’évolution du projet

 

Tout d’abord, nous avons envisagé pour la partie calcul et l’affichage du menu de réaliser un bus I2C entre 2 microcontrôleurs dont 1 partie s’occupera de la partie calcul et une s’occupera de la partie menu car lorsque nous essayons de fusionner les 2 programmes , le microcontrôleur n’a pas la capacité de mémoire suffisante pour réaliser ces deux tâches.
Puis nous pourrons utiliser un module GPS qui permettra d’avoir directement l’heure et la date au lieu de laisser l’utilisateur les rentrer.
Maintenant qu’on a le programme pour faire tourner le moteur comme on veut en fonction des calculs, nous devons trouver une solution pour implémenter les moteurs sur la monture, c’est à dire trouver à quel endroit et comment les placer sur la monture.
Il faudra ensuite faire en sorte de rajouter des roues de bonnes dimensions pour entrainer les axes avec la rotation du moteur pour obtenir le bon degré de rotation.
Une fois toutes ces perspectives d’évolutions mises en place, nous aurons un vrai système go-to qui sera donc capable de pointer une étoile avec pour seul intervention de l’utilisateur le choix de cette étoile depuis un menu.


Bilan

 

Dans l’ensemble, la direction à donner au projet était claire, nous savions quoi faire et comment le faire. La grosse difficulté de ce projet était de se familiariser avec l’astronomie, un domaine complètement inconnu pour les 3 membres de notre groupe. Ensuite, le succès de notre projet résidait dans la programmation, de ce fait nous avons passer beaucoup de temps à bien comprendre et implémenter les différents calculs, puis la mise en place d’un clavier et de l’écran LCD pour afficher les résultats.

 

Ce projet nous a fait prendre conscience de la difficulté d’aborder un sujet complètement nouveau, malgré le fait que tout les calculs sont déjà faits, expliqués et publiés partout sur internet, on se rend compte que programmer un calcul sans le comprendre n’aboutit jamais.

⇑Sommaire

 


Définitions à connaitre

 

Ascension droite :

Un des deux termes associés au système de coordonnées équatoriales avec la
déclinaison. Elle est l’équivalent sur la sphère céleste de la longitude terrestre. Tout comme la
longitude d’un lieu mesure l’angle entre le méridien de ce lieu et un méridien de référence appelé
aussi méridien principal, l’ascension droite d’un astre mesure l’angle entre le cercle horaire de cet
astre et un cercle horaire de référence. Le point vernal correspond au point de référence où l’angle
vaut zéro. (Exemple Nébuleuse du crabe M1 du catalogue de Messier: asc=5h 34m 31,97s) S’exprime
en radian. (1s d’ascension droite vaut 1/240 degrés et vaut 15s d’arc).

ascension droite

Déclinaison :

Un des deux termes associés au système de coordonnées équatoriales avec l’ascension
droite. C’est l’angle mesuré sur un cercle horaire entre un point de la sphère céleste et l’équateur
céleste. Elle est exprimé en degrés, minutes et secondes d’arc. (Exemple Nébuleuse du crabe M1 du
catalogue de Messier: D= +22° 00’52,1″ où les primes représentent respectivement les minutes et
les secondes d’arc) S’exprime en radian.

 

Calendrier Julien :

Il compte le nombre
de jour depuis la date de sa création il est donc très facile de connaître un intervalle de temps il
suffit simplement de soustraire ses date, alors qu’en calendrier Grégorien il faudrait faire attention
aux années bissextiles etc…

 

Temps sidéral :

Somme de l’ascension droite d’un astre et de sa déclinaison. Il mesure le déplacement de
la voûte céleste en un lieu donné par rapport au méridien local.

 

Azimut :

Axe horizontal autour duquel on tournera la monture du télescope.

 

Altitude :

Axe vertical autour duquel on tournera la monture du télescope.

⇑Sommaire

 


Webographie

 

Voici les liens des sites qui nous ont aider à réaliser notre projet :

Comprendre les unités angulaires
Compréhension des repères
Vérifier si les calculs du programme nous donnent le bon résultat
Aide au calcul pour temps sidéral à Greenwich

⇑Sommaire

 


Remerciements

Nous tenons à remercier notre enseignant Mr HAEBERLE de nous avoir accompagnés et conseillés durant ce projet, et pour nous avoir fourni les documents nécessaires à la réalisation du projet.

⇑Sommaire

 


Conception d’une prise électrique à switch automatique

  • Introduction

Lors de notre deuxième année en DUT GEII, nous sommes amenés à travailler sur un projet de notre choix, nous avions juste à soumettre nos idées au professeur, à savoir Monsieur Ould Abdeslam. Après longue réflexion, nous nous sommes décidés pour un projet de multiprise « intelligente ». Nous avons décidés de coupler cette multiprise à une Raspberry afin de traiter les informations recueillies par les différents capteurs mis en œuvre dans ce projet.

  • Présentation du Sujet

Cette « multiprise intelligente » est capable d’effectuer plusieurs mesures auprès des appareils branchés sur celle-ci permettant ainsi au consommateur d’être maître de sa consommation électrique. Il pourra connaître la consommation électrique de chacune des 8 prises composant la multiprise et, suivant l’appareil qu’il aura choisi de brancher dessus, il aura plusieurs modes à sa disposition lui permettant par exemple d’ouvrir le circuit lorsque son smartphone ou son pc portable sera chargé ou encore de connaître la qualité du courant utilisé (présence d’harmoniques). Dans l’idéal nous aimerions aussi mettre au point une interface pour smartphone lui permettant de gérer l’ensemble des fonctionnalités de manière simple et intuitive si le temps nous le permet.

Ce projet d’une durée de 1 mois se clôture par une évaluation d’un site mis au point par nos soins ainsi que d’une vidéo récapitulative que nous réaliserons.

Nous sommes maintenant sensibilisés au travail de projet puisqu’il s’agit du troisième projet à notre actif depuis le début de notre formation, nous évoluons donc en parfaite autonomie, sans que des cours de conduite projet nous soient dispensés comme ce fût le cas lors de nos précédents projets. L’évaluation portera aussi sur notre esprit d’équipe, notre implication et le sérieux dont nous avons fait preuve au cours de toute la durée de notre projet.

 

Pour se faire, nous sommes une équipe de deux étudiants à savoir :

  • Louis SPIESSER
  • Guillaume MAILLARD

 

  • Cahier des Charges

Schéma « Bête à corne » :

 

Bête à corne

Schéma « Pieuvre » :

 

Pieuvre

 

Fonction Principale : Rendre notre Multi-prises attractive afin de rendre le public attentif sur sa consommation électrique.

Fonctions Contraintes : Nous devons faire face aux éventuelles contraintes rencontrées pour faire de notre multiprise un projet rentable, intéressant et pédagogique.

 

  • Contrainte énergie : La contrainte énergie est en rapport avec l’utilisation de l’électricité, nous devons faire quelque chose d’optimal. C’est-à-dire réfléchir à chaque circuit électrique et à chaque composant afin de minimiser les pertes électriques.
  • Contrainte de compréhension : Nous devons rendre les données récoltées compréhensibles par le public.
  • Contrainte sécurité : Il faut assurer une sécurité suffisante afin de garantir la sécurité des usagers. Effectivement les prises sont alimentées en 220V et 16A ce qui s’avère dangereux en cas de dysfonctionnement.
  • Contrainte Informatique : Nous utilisons une Raspberry afin de lire et analyser les données récoltées par les capteurs. Au delà de ça, nous aimerions créer une interface visuelle afin de rendre le projet plus intuitif et permettre à l’utilisateur de choisir entre différents modes. La prise en main et la maîtrise des différents logiciels permettant sa programmation sont donc nécessaires.

Bien sûr la taille ainsi que l’ergonomie sont aussi des points importants pour ce projet.

 

  • Développement

Pour vous montrer les idées de ce projet voici un schéma explicatif.

 

Capture

Pour vous expliquer plus en détails, la multiprise est pilotée par une Raspberry PI capable d’envoyer une consigne binaire (0 & 1). Ce signal nous permettra d’alimenter chacune des prises selon le besoin par le biais d’un circuit imprimé. Cette consigne traverse une série de composants jusqu’à l’activation de la prise et ainsi l’alimentation de l’appareil branché. Grâce à un programme python, nous commandons les différentes séquences à envoyer à la multiprise.

La présence de la Raspberry nous permet de traiter des données. En effet, le but étant de calculer la consommation des appareils branchés, nous obtenons par le biais de capteurs de courant les signaux et les spectres de chaque prise activée. Nous pouvons ainsi lire et analyser les données obtenues afin de les afficher sur une interface crée a partir de la Raspberry afin de faciliter la compréhension de l’utilisateur.

Ce système permet alors de contrôler la consommation des appareils branchés afin de réduire au maximum les pertes d’énergies.

 

  • Conception

Pour assurer le bon fonctionnement du circuit nous avons dans un premier temps voulu comprendre comment se comportent les différents composants que nous allions utiliser à savoir les capteurs de courants, les relais ainsi que les optocoupleurs.

De ce fait nous avons établis le schéma général de notre projet dans lequel y figure ces derniers :

 

schéma géné

 

 

 

 

 

 

 

 Schéma général d’un des huit étages de la multiprise

 

PR1: Bloc résistances.

JP2 : Raspberry, envoyer consigne et récolte des données.

U19 : Optocoupleur, protéger la Raspberry d’un éventuel retour de tension.

U1 : ULN, amplifie le courant à la sortie de l’optocoupleur.

K1 & J1 : Relai 3 contacts avec sorties connecteur.

 

  • Capteur de courant

 

test capteur

 

A partir du DataSheet spécifique à notre capteur, nous avons établis un montage sur une plaque d’essai. Nous avons ainsi alimenté ce capteur et y connecté un élément consommant assez de courant pour obtenir une mesure. Cette mesure a été prise à la borne de VIOUT.

 

 

 

 

 

 

Conception du support capteur :

Capture Eschéma

capt

 

Une fois notre montage effectué sur une plaque d’essai, nous avons procédés à l’impression du circuit imprimé correspondant pour y accueillir notre capteur de courant. A suivi le test du capteur, non concluant par faute de calibre (20A). Nous avons ainsi décidé de changer le calibre pour passé à un plus petit (5A). Nous avons obtenu le signal ci-dessous qui correspond au courant absorbé par l’appareil branchés.

 

TEK00000

Ce test nous a permis de s’assurer du bon fonctionnement du capteur choisi. Cette simulation sera la même sur notre circuit imprimé, chaque capteur relié a chaque prise, prendra les données de la consommations des appareils branchés.

 

 

  • Présentation Raspberry

Image1

Lancé en 2013, le Raspberry Pi est un nano ordinateur détaillé. L’IUT a mis à notre disposition la dernière version, le Raspberry Pi 3. Celui-ci possède un processeur ARM de 1200 MHz, 4 ports USB, 1 port Ethernet, un module Bluetooth, un port HDMI, une prise audio 3.5 mm et un lecteur de carte Micro SD.

Le Raspberry Pi propose aussi des ports GPIO (General Purpose Inputs Outputs) qui nous permettent d’y brancher différents modules matériels tels que des capteurs comme c’est notre cas dans ce projet.

 

Afficher l'image d'origine

 

 

Nous avons plusieurs sorties/entrées à notre disposition (GPIO x) qui nous permettrons d’y connecter nos huit prises ainsi que nos capteurs.

Nous les relirons ensemble sur la masse commune de notre Raspberry (GND).

 

 

 

 

 

 

  • Codage Python de notre Raspberry

Nous avons réaliser plusieurs essais afin de se familiariser avec la programmation de la Raspberry. Ils consistaient à contrôler différents composants à l’aide d’un programme écrit par nos soins.

testrasp1

Clignotement d’une LED à partir d’une consigne GPIO Raspberry (présence d’une résistance de 270 Ohms pour protéger la LED)

 

Ce montage ainsi que de son programme adéquat nous a permis de simuler l’activation d’une des huit prises. En effet, l’appui sur le bouton poussoir nous permet d’allumer la LED qui reste dans cet état tant que nous n’avons pas ré-appuyé sur ce même bouton. Il s’agit donc du même principe pour envoyer une consigne d’activation ou de désactivation de la prise.

 

programme + mon,tage

Consigne continue permettant de choisir le temps d’activation de la LED

  • Programme de gestion des ports GPIO

Du côté de la programmation de la Raspberry, nous avons dû nous atteler à la programmation de ses ports GPIO afin d’alimenter nos différents relais.

Néanmoins, avant d’avoir pu travailler sur ce même but, nous avons été dans l’obligation de tester chacun des différents ports de la Rpi afin de s’assurer du nombre de GPIO disponibles, la désignation de certains d’entre eux étant parfois approximative voire inexistante pour certains.

Une fois cette partie de « reconnaissance » effectuée; il a donc fallu configurer les différents ports en sortie afin de permettre une alimentation du relai en 3.3 V, nous avons pu bénéficier du squelette de notre programme mis à disposition sur le site lwiringPi disponible à cette adresse: http://wiringpi.com/examples/testing-wiringpi-v2/.

Dans l’exemple ci-dessous, nous nous contentons de la configuration d’un seul port dans un premier temps (correspondant donc à un de nos 8 étages), la variable a étant donc le numéro du port que nous souhaitons configurer.

Ce programme peut être facilement testé en y raccordant une diode ainsi qu’une résistance afin de s’assurer de la bonne alimentation de la diode et donc du bon fonctionnement du port en question. C’est d’ailleurs ce que nous avons été contraints de faire, notre circuit n’étant pas encore en état de fonctionnement.

IMG_0224
Programme python sur Raspberry

Toujours dans ce même exemple, une fois notre programme compilé et lancé, nous pouvons constater l’incidence de celui-ci dans le tableau récapitulatif des différents ports de la Rpi ci-dessous. On constate effectivement que le port 1, correspondant au premier GPIO est bien passé à l’état de sortie.

B3E4D406-2EEF-4CB1-8D7C-016751CB0456
Affectation des sorties GPIO

Conception du circuit imprimé

Montage 1 étage (1 prise)

1etage

A partir de ce schéma, nous avons voulu tester le bon fonctionnement avant d’imprimer le schéma complet. Nous voulions être du bon fonctionnement du projet avant de se lancer dans la réalisation complète qui aurait pris du temps et beaucoup de composants si elle s’avérait défectueuse. Nous avons alors fait les essais sur une plaque de test.

Test du schéma un montage

On observe branché dans l’ordre comme ci dessus, Optocoupleur, ULN et Capteur.

IMG_2078
Test sur plaque d’essai

Montage général

Après fonctionnement sous souhaitions développer le schéma général à la taille réelle (8 prises). Nous avons ainsi créée le circuit imprimé complet du projet

 

schema complet
Schéma général sous Eschema
dzadza
Schéma général sur PCBNew

 

Afin d’élaborer ce schéma, nous avons du nous référer au Datasheet de chaque composant afin de crée de nouveau modèle de composant. Nous avons donc redessiné les composants pour les intégrer aux bibliothèques du logiciel.

creation nouveau composant
Création de l’empreinte de l’ULN

Le respect des distances entre chaque PAD, est primordial, il correspondra aux trous de perçage pour intégrer le composants sur le circuit.

 

  • Bilan

Arrivés à l’issue de ce projet, nous avons eu l’opportunité de travailler sur un projet assez élaboré avec de beaux enjeux, nous avons eu l’occasion de manipuler et de prendre en main une multitude de composants (optocoupleurs, relais, amplificateur de courant, capteur de courant, abaisseurs de tensions, etc..) que nous n’avions jusqu’alors jamais connus. De bonnes idées en ont découlé, le projet dans sa partie théorique était bien établi dans nos esprits, notre esprit d’initiative a lui aussi été sollicité et de belles choses en ont découlé. Même si au final notre projet laisse de côté un bon nombre de critères que nous espérions mener à bien comme la mise au point de scénarios ou encore la mise au point d’un interface, ce projet impliquait énormément de tâches intermédiaires à accomplir, tâches dont nous nous sommes pas rendu compte tout de suite et qui nous ont fait perdre beaucoup de temps. Sur toute la durée de ce projet, nous en sortons tout de même bien enrichis: En effet, la lecture de datasheets, la prise en main des différents composants et la mise au point de notre propre circuit imprimé ne sont que les exemples majeurs des connaissances que nous avons acquises durant notre projet.

  • Problèmes rencontrés

Un problème de gestion du secrétariat du l’IUT nous a retardé, en effet le déblocage de fond étant impossible nous avons été contraint à nous limiter à la partie théorique pendant un long moment. Cette partie était certes nécessaire afin de  le projet mais cependant trop longue. Ainsi n’ayant pas pu travailler avec nos composants dès le début, nous avons dû nous contenter d’hypothèses pour réfléchir à l’avancement du projet. Nous nous sommes alors renseignés pour les branchements de chaque composant sans pouvoir les tester directement. La vérification de chaque composant et la mise en relation de ceux-ci nous pris beaucoup de temps. Nous avons dus remodeler beaucoup de montages sans vrais résultats. Les problèmes principaux ayant été cités, nous avons eu à faire face – comme dans tout projet –  à une multitude de problèmes moindres comme par exemple des problèmes de configuration de la Raspberry, des problèmes à reprendre en main Kicad

  • Choix des composants 

 

Connecteurs 2 contacts : http://fr.rs-online.com/web/p/borniers-pour-ci/8024849/

Capteur de courant : http://fr.rs-online.com/web/p/capteurs-de-courant/8660767/

Relais sans accrochage : http://fr.rs-online.com/web/p/relais-sans-accrochage/0366259/

Fiche 4mm : http://fr.rs-online.com/web/p/fiches-et-prises-de-test-4-mm/0404171/

Optocoupleurs : http://fr.rs-online.com/web/p/optocoupleurs/6912154/

 

  • Bibliographie & Sources

Datasheet Capteur de courant ACS723 : http://docs-europe.electrocomponents.com/webdocs/13b5/0900766b813b538c.pdf

Utilisation de la Raspberry :

  • https://espaceraspberryfrancais.shost.ca/Autre/Connecter-Raspberry-au-PC-par-cable-Ethernet-Francais/
  • https://wiki.electroniciens.cnrs.fr/index.php/Installation_d’une_cha%C3%AEne_de_compilation_crois%C3%A9e_(GCC)_sous_Eclipse
  • https://www.youtube.com/watch?v=DcNHmtlL3AU

 

 

 

 


Acquisition des données avec Labjack U3-HV//HSINI HAMZA.

1images[3]

IMG_0856

 

Projet : Acquisition des données avec un LabJack

Hsini Hamza

 

 

I-INTRODUCTION :

 

Lors de cette deuxième année , on est amenés à la réalisation d’un projet , celui-ci doit être en lien direct avec notre formation ( génie électrique et informatique industrielle) , pour notre cas , il s’agit du projet intitulé « Acquisition des données avec Labjack U3 » , ce projet rentre dans le cadre du module « études et réalisations » dont la notation dépend des efforts fournies (avancement du projet) , ainsi que le rapport et la vidéo .

Notre projet serait alors d’acquérir des données depuis des capteurs et faire des mesures puis  .L’acquisition de donnée se fera alors à l’aide d’un Labjack U3-HV , qui a pour avantage une acquisition continue des données , ce qui pourrait nous éviter la perte de ces derniers.

II-Outil et matériel :

C’est quoi un Labjack?

Labjack est un outil de mesure et d’automatisation qui dispose de plusieurs Entrées/Sorties analogique et numérique .3 C’est comme une interface de liaison entre le monde physique et l’ordinateur

Un Labjack peut faire :

 -Lire les sorties des capteurs qui mesurent (courant/tension/puissance/température/humidité/vitesse du vent/pression/accélération…) et ensuite enregistrer ces données sur l’ordinateur où peuvent par la suite être transférées dans une base de données.
-contrôler des moteurs, lumières, relais…

Le Raspberry PI 3:

2

C’est un mini-ordinateur qui permet à la fois de faire l’électronique ou de la robotique (grâce aux GPIO) mais aussi à se faire un serveur multimédia (avec XBMC) ou une machine pour faire l’hébergement Web voire un ordinateur d’appoint pour moins de 50€.

Pourquoi un Raspberry et pas un ordinateur:RPi_LOGO_TEXT_REG_RGB

Parce que tout simplement je n’arrivais pas à installer les librairies ainsi que les drivers sur mon ordinateur personnel qui est un mac, à chaque tentative on avait la même erreur qui est« libusb1-0 » file not found, on a donc décidé alors de travailler avec un Raspberry PI 3 accompagné de son écran LCD 7°.

III-Cahier des charges :

ch

Bête à corne :

 peiu

Diagramme de pieuvre :

bibi

 benj

IV-Réalisation :

Les étapes à suivre :

  • Installation des pilotes
  • Compréhension du programme de Streaming
  • Modifier la fréquence d’échantillonnage et le nombre de ports
  • Modifier le temps d’enregistrement
  • Mesures réelles de courant et tension

1) Installation des pilotes :

On a du travailler avec un Raspberry qui marche sous Linux car on a pas pu installer les drivers sur mon ordinateur personnel :
Il faut commencer dejà par installer la librairie Libusb1-0 , après installer l’exodriver qui se fait le répertoire de ce dernier :
sudo ./install.sh

Puis on commence à builder les programmes examples :
cd examples/u3/
make

Pour exécuter un des programmes examples :
./u3Stream

2) Compréhension du programme streaming :

159
Ce bout de programme représente la configuration du streaming .

3) Modification de la fréquence d’échantillonnage et nombre de ports :

bnnz

Configuration nombre de ports :

pchakh

2017-01-18-120528_800x480_scrot

Quand on change le nombre de ports le terminal m’envoie une erreur de segmentation il faut donc changer le scanInterval aussi (on peut le calculer en fonction du nombre de ports ) pour la fréquence d’échantillonnage maximale .

En changeant le scanInterval l’erreur de segmentation est toujours là , il fallait donc changer une ligne dans le code .longc

il faut mettre le NumChannels en double aussi  : double voltages[voltagesSize][NumChannels];

4) Sauvegarde du flux de données dans un fichier txt :

C’est l’un des but de ce projet , il faut enregistrer le flux de donnés fournit par le Labjack en même temps que ce dernier fait l’acquisition des données pour ne pas interrompre le pogramme .

Pour faire cet enregistrement il faut modifier le programme U3stream afin qu’il puisse ouvrir et modifier un fichier txt en fonction des données que le LabJack acquérait.On va alors utiliser la fonction ofstream .

Exemple d’un programme de lecture et modification d’un fichier txt :

benj

résultat :

bnjcity

Pour le programme de streaming on va essayer de rajouter des pointeurs sur les valeurs AI0 et AI1 et les renvoyer sur le fichier txt .