Quentin DEFOSSEZ

Rapport de stage Du 29 mars au 12 juin 2010

Entreprise : Dounor

Sujet : Récupération de données sur automates Siemens

Encadré par :

M. DENOEUD en entreprise

M. FREMEAUX en entreprise

M. COCQUEMPOT à l’université

Année scolaire 2009 – 2010 Institut Universitaire de Technologie de Lille1, Villeneuve d’Ascq

Section GEII

Page 2 / 40

Sommaire

Remerciements ................................................................... 3

Présentation de l’entreprise................................................. 4

I - Introduction.................................................................... 7

1. Problématiques liées à l’entreprise......................................................................7

2. Présentation et objectif des sujets........................................................................7

3. Les outils informatiques ......................................................................................9

4. Les outils électriques ...........................................................................................9

5. Kepserver...........................................................................................................10

6. Schéma de communication des données ...........................................................11

II - Travail effectué........................................................... 12

1. Quantités de matières premières consommées..................................................12

2. Lecture instantanée d’une coupe en cours.........................................................16

3. Informations sur la dernière coupe....................................................................19

4. Recyclage du non-tissé en excès .......................................................................27

5. Installation d’un variateur pour moteur à courant continu................................30

III - La finalité du projet ................................................... 32

IV - Conclusion................................................................. 33

Annexes ............................................................................ 34

Page 3 / 40

Remerciements

Je tiens en premier lieu à remercier M. Pierre DENOEUD, mon tuteur en entreprise, responsable électrique à Dounor, de m’avoir beaucoup aidé à prendre en mains les outils de travail et qui m’a suivi tout au long de l’avancement de mon projet.

Je remercie également M. Simon FREMEAUX, mon deuxième tuteur en entreprise, responsable technique à Dounor, qui m’a soutenu dans ma démarche de stagiaire et qui a notamment régulièrement souhaité un compte rendu sur mon avancement.

Je remercie M. Vincent COCQUEMPOT, mon tuteur à l’université de m’avoir apporté de multiples conseils et qui est venu me rendre visite durant mon stage.

Je tiens notamment à remercier M. DELERUYELLE et M. BOUSSEKEYT, deux enseignants en informatique, car les cours dont j’ai eu l’opportunité de suivre sur Visual Studio et Visual Basic m’ont beaucoup aidé à la réalisation de mon projet, je remercie aussi M. POMORSKI pour son enseignement en télécommunication et réseau ainsi que l’ensemble des mes professeurs durant mes 2 années universitaires.

Je remercie M. David BROUTIN, responsable des stages à l’université, ainsi que L’IUT-A et l’université de Lille1 qui m’ont permis de réaliser ce stage en entreprise.

Je remercie M. Christophe WILLOT, directeur de la société Dounor, de m’avoir permis de réaliser mon stage au sein de son entreprise.

Je remercie également M. Alexis FOOR, gérant de l’usine, mes coéquipiers de travail au sein du service électrique : MASURE Olivier, ROBLIN Ludovic et LECHNIAK Philippe, ainsi que l’ensemble du personnel de Dounor avec lequel j’ai pu travailler en collaboration durant ces 11 semaines de stage.

Page 4 / 40

Présentation de l’entreprise

1. La société

Date de création : 1986 Adresse : Neuville-en-Ferrain, 30-32 rue du Vertuquet Chiffre d’affaire : 55 Millions d’euros / an en 2009 Effectif : 150 salariés Marché : Principalement européen Activité : Fabrication de non-tissé (35000 tonnes/an) Application : Couches bébés, incontinence adulte, hygiène féminine.

Cette entreprise familiale créée en 1986, contient aujourd’hui 8 lignes de production, elle fabrique des bobines de non-tissés à partir de granulés de polypropylène, principalement destinées au marché de l’hygiène tel que les couches bébés, l’incontinence adulte et l’hygiène féminine.

Cette usine travail 24h/24, 7j/7 et 365 jours par an, elle emploie aujourd’hui 150 personnes, dont la moitié est attitrée à la production. Au sein de l’entreprise les journées commencent à 5h, les équipes de production sont postées selon un cycle de travail de 6 jours de suite : deux matins de 5h à 13h, deux après-midi de 13h à 21h et deux nuits de 21h à 5h, suivis de 4 jours de repos.

2. Historique :

1986/1989 : Ligne 1 et 2 « Carde » : Leurs applications sont destinées à l’hygiène bébé, hygiène féminine et lingettes, leur capacité annuelle de production représente 1500 tonnes. 1991 : Ligne 4 « Filature » : Des fibres synthétiques sont obtenues en sortie, ses applications sont destinées au non-tissé thermo lié et non-tissé aiguilleté, sa capacité annuelle de production représente 6000 tonnes. 1993 : Ligne 3 « Spunbond » : Spunbond indique qu’il s’agit d’une tête extrudeuse de type filière. Ses applications sont destinées à la fabrication de matelas, packaging et auto motive, sa capacité annuelle de production représente 1500 tonnes. 1997/2000 : Ligne 5 et 6 « Spunmelt » : Spunmelt indique la présence de deux têtes extrudeuses Spunbond et d’une ou plusieurs tête extrudeuse de type Meltblown, ici deux têtes Spunbond et une seule tête Meltblown, d’où l’appellation de lignes de type SMS (voir le schéma du procédé de fabrication page 6). Leurs applications sont destinées à l’hygiène bébé, hygiène féminine, incontinence adulte, médical et filtration, leur capacité annuelle de production représente 5000 tonnes.

Page 5 / 40

2003 : Ligne 7 « Double Spunbond » : Type SS, ses applications sont destinées à l’hygiène bébé, hygiène féminine, incontinence adulte, building et filtration, sa capacité annuelle de production représente 8000 tonnes. 2007 : Ligne 8 « Spunmelt » : Type SXMMS (X désignant la possibilité de rajouter une tête extrudeuse). Cette dernière arrivée fut l’investissement de 30 millions d’euros, ses applications sont destinées à l’hygiène bébé, hygiène féminine, incontinence adulte, médical et filtration, sa capacité annuelle de production représente 12000 tonnes. 2007 : Recyclage « Erema », Cette machine retransforme à l’état de granulés de polypropylène le non-tissé, tel que les bobines d’essais ou en erreur. Sa capacité maximum de production peut atteindre 1 tonne par heure.

3. Le marché

Localisée aux portes de l’Europe, cette industrie y affiche plus de la moitié de son chiffre d’affaire :

- 56% en Europe ; - 28% en France ; - 16% pour le grand Export.

Les différents domaines d’activités dans lesquels Dounor réalise son marché sont :

- Hygiène : Couches bébés, Incontinence adulte et hygiène féminine. - Médical : Blouses, draps chirurgicaux, pansements, compresses, lingette, emballage de

stérilisation, masque antigrippes - Essuyage : Lingettes nettoyantes - Agriculture : Voiles de forçage et d’hivernage - Autres : Matelas, dessous de fauteuils, filtres d’habitacle automobile.

4. Le procédé de fabrication

C’est par de multiples mécanismes que le produit se transforme : 1) Les granulés de polypropylène sont acheminés et stockés provisoirement dans des silos d’une capacité allant de 50 à 100 tonnes. 2) Grâce à une tête de dosage, les granulés sont d’abord injectés à l’intérieur d’une extrudeuse (vis sans fin chauffé à 240 degrés) à l’intérieur de laquelle la matière est broyée pour être transformée à l’état fondu. - Pour une tête extrudeuse « Spunbond », ce produit fondu sort en plusieurs dizaines de milliers de filaments grâce à une filière. Dans le canal d’étirage, ces filaments sont ensuite refroidis puis étirés et enfin "nappés" sur un convoyeur. - Pour une tête extrudeuse « Meltblown », le polypropylène est soixante fois plus fluide comparativement au polypropylène à la sortie d’une tête extrudeuse « Spunbond ». Ce produit est donc soufflé sur le convoyeur entre deux couches de « Spunbond ». Le schéma de principe de ces deux têtes extrudeuse est consultable en annexe, page 37

Page 6 / 40

3) Ensuite le complexe obtenu traverse la calandre : le voile est thermo-fixé par compression entre un rouleau compresseur lisse et un rouleau compresseur avec motif, tous deux chauffés afin d’assembler les filaments de non-tissé. 4) Le voile est ensuite imbibé : c’est le traitement par ensimage (solution chimique en milieu aqueux), cette étape facultative donne au non-tissé ses propriétés de porosité, suivi du passage dans un séchoir. 5) Afin de détecter d’éventuelles erreurs sur le non-tissé, telle que des trous ou des épaississements non désirés, des caméras performantes et une jauge de profiles (permettant de mesurer le grammage) viennent s’ajouter à cette chaîne. 6) Ce voile est ensuite coupée afin de donner la ou les largeurs demandées, il l’est également aux deux extrémités pour ne pas les ajouter au produit fini car celles-ci ne sont pas d’une qualité homogène, elles sont appelées lisières. Ces lisières sont ensuite aspirées travers une tuyauterie afin d’être directement recyclées. Puis elles sont directement réinjectées dans le processus depuis la transformation à l’état fondu qui commence à travers une extrudeuse lisière et acheminées dans l’extrudeuse principale. 7) Ce voile de non-tissé est ensuite enroulé autour d’un tube. Lorsque la bobine est terminée un autre tube vient remplacer cette bobine par un système de renversement, puis le bras de coupe vient couper le voile en travers qui vient s’enrouler sur le tube encore vide. La bobine terminée est déchargée de la ligne de production. 8) Enfin, les bobines de non-tissés sont emballées et stockées avant d’être récupérées par transporteur.

Procédé de fabrication d’une Ligne de type SMS « Spunmelt » (Ligne 5 et 6) :

Le procédé de fabrication des lignes de production 7 et 8 sont consultables en annexe page 38.

3

2

4 5 6 8

7

1

9

Page 7 / 40

I - Introduction

1. Problématiques liées à l’entreprise

La conjoncture actuelle demande à toute entreprise de réduire ses coûts de production et par conséquent de calculer correctement ses consommations et productions. C’est pourquoi la société Dounor a demandé de réaliser une base de données afin d’optimiser cette chaîne en travaillant sur :

- La récupération d’un historique aujourd’hui trop succinct des quantités de matières consommées sur une ligne.

- La création d’une relation longueur instantanée en fonction du diamètre correspondant d’une bobine pour une campagne de production donnée.

- La création d’un historique sur les informations des bobines produites aujourd’hui inexistant.

- La quantification du pourcentage de matière recyclée injectée sur les lignes de production.

2. Présentation et objectif des sujets

L’objectif final est d’adapter chacun de ces quatre sujets à chacune des quatre lignes de production les plus récentes, à savoir les lignes 5 à 8 :

1- Récupération d’un historique des différentes matières consommées sur une ligne de production : Le but consiste à récupérer de manière automatique, sur la base de données située sur le serveur, les quantités de matières premières et additives injectées sur les différentes lignes de production. Ci-contre une photo représentant une tête de dosage, cela englobe la trémie principale contenant la matière première, c’est-à-dire le polypropylène et les trémies de matières additives, ici des colorants. En outre, il y a sur chaque ligne de production entre 2 et 4 têtes de dosage et sept trémies par tête (le polypropylène et six produits additifs facultatifs).

2- Lecture instantanée de la longueur d’une bobine en production en fonction de son diamètre. Ce sujet à pour but de relever le diamètre instantané d’une bobine en fonction de sa longueur instantanée, à un intervalle de longueur définie par l’utilisateur. Actuellement, lorsqu’un défaut apparaît sur une bobine en traitement, un message sur l’ordinateur informe l’opérateur en indiquant l’endroit du défaut. Selon la nature et l’importance du défaut, il est souhaitable de pouvoir extraire ce défaut par une découpe transversale de la bobine, ce qui est impossible sans savoir à quel diamètre le défaut se situe. J’ai réalisé le fichier « Lecture instantanée » qui s’utilise ponctuellement. Lorsqu’il est en exécution, il affiche et enregistre en temps réel à chaque intervalle de longueur souhaité la longueur et le diamètre de la bobine en cours.

Une tête de dosage :

Page 8 / 40

3- Création d’un historique d’informations sur les coupes afin d’en récupérer une traçabilité pour le service qualité. C’est probablement le sujet le plus complexe, mais le plus utile et enrichissant à concevoir : Lorsqu’il y a un renversement, c’est-à-dire lorsqu’une bobine est terminée, il faut récupérer les informations correspondant à cette coupe telle que la date, l’heure, le numéro de coupe, la durée, la longueur programmée au départ, la longueur réelle mesurée et le diamètre de la bobine.

4- Récupération d’un historique des quantités de matière recyclé en granulés de polypropylène. C’est le secteur de recyclage des bobines d’essai ou usagées afin de les transformer dans leur état d’origine : en granulés de polypropylène. Le non-tissé est dans un premier temps broyé puis fondu, granulé et enfin séché. Ces granulés sont transférés dans un silo intermédiaire avant d’être réinjecté au sein des différentes lignes de production.

5- Dans le cadre de ce stage j’ai réalisé d’autres interventions et je suis notamment intervenu sur l’installation d’un variateur pour un moteur à courant continu.

Ce variateur de type Siemens remplace l’ancien de marque Mentor qui ne fonctionnait plus. Il est destiné au fonctionnement d’un moteur à courant continu qui fait tourner la vis sans fin d’une extrudeuse lisière, par l’intermédiaire d’une courroie.

Bobines produites

Bobine suivante

Bras de coupe en cours de descente

Un renversement :

Fin de chaine de recyclage :

Page 9 / 40

3. Les outils informatiques

- J’ai commencé par des essais sur une maquette d’un automate avec son jeu d’interrupteurs connectés afin de me familiariser avec le matériel Siemens. J’ai effectué durant une semaine des petits travaux consistants à récupérer et manipuler des bits sur le tableur Microsoft Excel lors du maniement sur les interrupteurs.

- Le logiciel de programmation d’automate Step7 de Simatic, car la totalité des automates de l’usine sont de technologies Siemens.

- Le logiciel Microsoft Excel accompagné de son logiciel de programmation : VBA (Visual Basic for Applications).

- Le logiciel KEPServerEX de Kepware, qui joue l’intermédiaire entre les automates et le PC, décrit ci-après.

- Un serveur connecté à l’ensemble des lignes de production.

- Le logiciel de base de données : ODBC (Open DataBase Connectivity) sous Windows.

4. Les outils électriques (concernant le cinquième sujet)

- Le logiciel de création de schémas électriques : See3000.

- Un Banc d’essai électrique, afin de réaliser les tests du variateur.

- Le variateur de moteur à courant continu et sa documentation technique.

- Un moteur à courant continu.

- Le schéma de branchement de l’armoire électrique, avant l’installation du variateur.

- Trois relais de contact permettant la commutation électrique lors d’une vitesse nulle, d’une vitesse atteinte ou d’un défaut.

Page 10 / 40

5. Kepserver

Pour réceptionner les données en réseau depuis les automates, j’utilise le logiciel Kepserver de Kepware. Il permet de lire les données sur les automates connectés en réseau. Les variables insérées au sein de l’automate depuis l’affectation par le logiciel de programmation Step7, sont récupérées par Kepserver. Le paramétrage pour chaque variable consiste à :

- Donner l’adresse et le nom de source de cette variable, - Donner un nom plus convivial à cette variable, qui va permettre sa récupération par la

suite sur Kepserver. - Donner son type de données

Concernant la ressource de ce logiciel, la société Dounor ne possède pas la licence complète, mais uniquement la version de démonstration, ce qui se traduit par une déconnexion forcée de Kepserver au bout de deux heures d’activité consécutive. Pour contourner cela, j’ai aménagé chaque fichier selon leur utilisation qui est développée pour chacun d’entre eux.

Variables déclarées

Copie d’écran de Kepserver lors du paramétrage d’une variable

Liste des groupes de variables

Nom de récupération

Adresse et nom source

Type de données

Page 11 / 40

6. Schéma de communication des données

Les automates Siemens sur lesquels sont récupérées les informations ont été installés par différents constructeurs. Sur le schéma ci-dessous, les automates sont appelés par leur nom de constructeur :

− Les automates Bastian contiennent les données concernant l’enrouleuse, − Les automates Vollmar contiennent les données concernant les dosages.

Voici comment les données sont acheminées depuis les automates de chaque ligne de production jusqu'au logiciel de Gestion de Production Assistée par Ordinateur (GPAO) de l’usine :

Sur ce schéma, je travail à l’aide d’un PC connecté en réseau avec le serveur appelé « D004 » et j’accède au bureau de ce serveur grâce au logiciel VNC (Virtual Network Computing). La finalité du sujet consiste à faire fonctionner chaque fichier Excel, Kepserver et la base de données sur ce serveur. Le service informatique développe ensuite la GPAO de façon à récupérer les valeurs contenues dans la base de données.

Page 12 / 40

II - Travail effectué

1. Quantités de matières premières consommées (Compta Matières.xls)

- L’objectif consiste à actualiser les valeurs de quantité au sein de la base de données chaque lundi matin à 5h et chaque premier jour du mois à 5h également.

- Ces données sont actuellement enregistrées dans les automates sur les douze derniers mois, ce qui représente une quantité importante de données à recenser. L’organisation et la lisibilité des valeurs ont dû être également étudiés. Pour ce faire j’ai opté pour un fichier à quatre onglets, avec une ligne de production par onglet et un affichage sur les douze derniers mois, ainsi que le mois en cours.

- Afin d’afficher les données en cours à un instant t, j’ai réalisé un bouton destiné à l’actualisation simple de la ligne de production. La difficulté est ici de faire correspondre les valeurs récupérées avec le mois correspondant qui n’est pas enregistré dans l’automate donc pas récupérable directement via Kepserver. J’ai donc affiché le mois en cours depuis les informations temporelles du PC d’exécution sur l’année n - 1, ce qui correspond aux premières valeurs enregistrées.

Procédure appelée lors du clic sur le bouton « Lire la ligne en cours » :

Page 13 / 40

- Un deuxième bouton d’actualisation de l’ensemble des lignes de production m’a semblé pratique d’utilisation afin de minimiser le temps de réception des données, alors que l’utilisateur devait auparavant les récupérer sur chaque ligne de production. La difficulté est de centraliser l’information afin d’agir sur l’ensemble des feuilles de calcul correspondant à chacune des quatre lignes de production. Pour cela, j’ai utilisé un module général qui m’a permis de faire le lien entre les différentes feuilles de calculs :

Procédure appelée lors du clic sur le bouton « Lire toutes les lignes » :

- Par simplicité pour l’utilisateur, j’ai rendu la connexion transparente, c’est-à-dire que celle-ci doit se faire automatiquement lorsque le fichier est sollicité, soit par le clic sur un des boutons de lecture, soit par la mise à jour automatique. La réalisation n’est pas difficile en soit, c’est au concept qu’il fallait penser : pas de bouton connexion, mais l’ajout d’une procédure « Connexion » appelée lorsqu’une actualisation est demandée. De même pour la déconnexion qui est placée directement avant la fin de la procédure « Lecture ».

Procédure « Lecture_Ligne5 » lors du clic

- La principale caractéristique de ce sujet consiste à effectuer la mise à jour automatiquement et que les valeurs soient ajoutées au sein de la base de données. Comme explicité plus haut, pour que la connexion s’établisse chaque lundi, j’ai dans un premier temps recherché la possibilité de mettre en place une horloge, de façon à pouvoir récupérer l’heure et la date en cours, puis dans un second temps de donner une condition de date et d’heure à cette horloge afin de lire l’ensemble des données pertinentes au bon moment.

Page 14 / 40

- Lors d’une connexion automatique, l’actualisation des données sur le tableur et sur la base de données se fait pour toutes les lignes de production J’ai donc placé cette horloge au sein du module général. De plus, des recherches sur des conditions de dates et d’heures ont été nécessaires à la réalisation de ce script.

Procédure « Horloge » au sein du module général

- On peut remarquer sur cet exemple l’appel des différentes procédures de mises à jour de la base de données, représentées par « Call Feuil1.Maj_semaine_BDD » ou « Call

Feuil1.Maj_mois_BDD », (BDD est l’acronyme de « Base De Données »). Ces deux procédures sont presque identiques hormis la lecture des données qui ne s’effectue pas au même endroit : soit sur le mois en cours soit sur le dernier mois enregistré selon une lecture le lundi ou lors d’un nouveau mois.

Procédure appelée lors de mise à jour de la base de données, un lundi matin à 5h

Page 15 / 40

- Pour effectuer ces mises à jour sur une base de données de type ODBC (sous Windows), en réseau sur le serveur, j’ai effectué différents essais afin d’aboutir à une solution simple et fonctionnelle. Celle que je propose ici est relativement interactive : j’insère dans une variable (représenté ici par « Tete_A ») du code SQL qui est ensuite envoyé dans la base de données correspondante. En prenant soin d’ouvrir la connexion et à l’aide des paramètres adéquats j’exécute la commande correspondante à l’envoi de cette variable texte SQL.

- L’objectif est de créer un affichage agréable sur la feuille de calcul tout en ayant une grande interactivité avec l’utilisateur. J’ai pour cela mis en place quelques commentaires de supervision permettant à l’utilisateur de savoir le statut de la feuille de calcul, ainsi que quelques informations utiles afin de mieux comprendre le fonctionnement de la feuille de calcul :

- Ce fichier contient au final pour l’utilisateur :

• quatre onglets correspondants aux quatre lignes de production, • deux à quatre tableaux correspondant à chaque tête de dosage, • des boutons d’action, • des informations de supervision.

Informations concernant le travail en cours

Les tableaux de données :

Les différentes actions possibles

Valeurs lues dans Kepserver

Sélection de la ligne de production

Page 16 / 40

2. Lecture instantanée d’une coupe en cours (Lecture instantanée.xls)

- Pour la réalisation de cet outil, j’ai choisi ici une utilisation interactive du fichier, J’ai créé deux boutons : « Lecture » et « Effacer », deux boutons d’option destinés à sélectionner une lecture en continu ou uniquement sur la bobine en cours et deux listes déroulantes permettant de choisir la ligne de production à étudier et le choix des intervalles de longueur qui va définir la fréquence d’actualisation des données.

- La principale difficulté concerne la lecture de la ligne 8 qui contient une donnée de plus à

afficher : la longueur optique, ce qui nécessite une colonne en plus. Pour avoir un affichage agréable et uniforme, j’ai donc séparé les lignes 5, 6 et 7 sur un premier onglet avec un tableau de valeurs unique et un deuxième onglet pour la ligne 8.

Procédure « Lecture » sur l’onglet destiné aux lignes 5, 6 et 7

- Si l’utilisateur sélectionne la ligne 8, l’astuce consiste à le diriger sur l’onglet correspondant sans que celui-ci s’en rende compte grâce à la fonction « Sheets("Ligne8").visible », en réduisant de la même façon l’onglet actuel. - Après avoir vérifié que l’utilisateur ait bien sélectionné l’ensemble des options, les variables suivantes sont enregistrées au sein de Visual Basic :

• La fréquence par une variable frequence de type entier, • La lecture continue ou non par une variable booléenne lecture_activee.

- J’affiche également sur le tableur les valeurs correspondantes aux variables sur Kepserver de

la ligne de production choisie. - Ensuite, une procédure Horloge est appelée au sein du module général, qui va permettre de décompter 1h59 si l’utilisateur sélectionne la lecture en continu et omettrait d’arrêter la lecture.

Procédure « Horloge » qui décompte 1h59 à partir de l’exécution de Kepserver

Page 17 / 40

- Lorsque tous les paramètres sont corrects, la procédure lecture lance la connexion et une procédure spécifique « DataChange » lit les données en permanence.

Procédure « DataChange » qui lit en continu la longueur instantanée

- Si la variable représentant la dernière longueur enregistrée (représentée par la variable

« derniere_longueur ») ajoutée à l’intervalle de longueur choisie (représentée par « frequence ») dépasse la longueur actuelle (représentée par « Values(1) », première valeur au sein du tableur), la ligne suivante au sein du tableau de données s’incrémente des valeurs correspondantes, à savoir la longueur et le diamètre actuels.

- Ces valeurs appelées sur le tableur représentent l’appel des variables sur Kepserver au nom convivial préalablement paramétré. Cette boucle s’effectue jusqu'à ce que l’utilisateur clique sur le bouton « Stop » ou lorsque la bobine est terminée si l’option de lecture unique est sélectionnée. - Lors d’un nouveau clic sur « Stop » appelant la procédure « Lecture », la variable booléenne « lecture_activee » étant à Vraie va ignorer l’étape du paramétrage pour au contraire remettre cette variable à Faux et déconnecter Kepserver.

Programme à effectuer si lors du clic sur Lecture, celle-ci est déjà active

- Lors du clic sur « Stop », je désactive la procédure « DataChange », je déconnecte Kepserver et ensuite j’appelle la procédure « Initialisation » qui va s’occuper de réinitialiser les listes d’options.

Page 18 / 40

- La ligne 8 est dotée en plus des autres lignes, d’un système de mesure perfectionné qui prend des images en continu du voile à forte vitesse avant l’enroulage. De ces images, un logiciel permet d’étudier chaque pixel afin de les additionner pour calculer la longueur.

Exemple de lecture instantanée en continu sur la ligne 8

Le principe de fonctionnement de la feuille « Ligne 8 » est identique au fonctionnement de la feuille « Ligne5, 6 et 7 », excepté une colonne supplémentaire qui affiche la longueur optique instantanée.

Bouton « Stop » qui s’affiche lors de la lecture et suit les valeurs descendantes.

Paramètres sélectionnés par l’utilisateur

Informations de supervision : Variables lues sur Kepserver

Bouton « Lecture/Stop »

Page 19 / 40

3. Informations sur la dernière coupe (Métrages.xls)

- Pour récupérer ces informations, j’ai dans un premier temps

réalisé les câbles de liaison entre les automates de la ligne 5 et 6 jusqu’au serveur à l’aide d’une paire torsadée écrantée avec blindage général assuré par une feuille d’aluminium et de fiches RJ-45 femelles. J’ai ensuite relié le Switch à l’automate à l’aide de câbles mâle/mâle.

- Afin de simplifier l’utilisation de cet outil, j’ai choisi une connexion automatique dès l’exécution du fichier afin d’être directement opérationnel. Pour cela, j’ai utilisé une fonction simple dans le module commun : « auto_open() ». Dès l’exécution de la feuille de calcul, cette procédure appelle la connexion :

- Afin de contourner le problème de licence de Kepserver, j’ai également installé une horloge qui décompte 1h59 lors de la connexion, au terme duquel la procédure horloge appelle la procédure de déconnexion et ensuite de connexion. Le décompte se réinitialise également et cette boucle s’exécute continuellement jusqu'à une déconnexion provoquée par l’utilisateur. Pour cela, de la même manière qu’énoncé pour le premier fichier, je place une horloge dans le module général qui va lire et afficher l’heure chaque seconde. Lorsque le temps imparti est dépassé, cette procédure appelle une reconnexion. Dans l’exemple qui suit, pour comptabiliser 1h59, j’initialise une variable start à la connexion contenant la date et l’heure réelle, puis je programme la condition start + 1h59 qui définit une reconnexion.

- Il y a une fonction d’attente (waitTime) de huit secondes qui permet de laisser le temps à

Kepserver de se déconnecter convenablement avant de se reconnecter. Si cette attente est négligée, la déconnexion n’a pas le temps d’avoir lieu qu’une nouvelle reconnexion est demandée et le fichier annonce un conflit puis s’arrête inopinément. On remarque la présence d’une variable booléenne « reconnection » étudiée plus loin.

Page 20 / 40

- On constate également le double l’appel d’une même procédure « Connexion_Click » pour la reconnexion. J’ai souhaité ici minimiser le nombre de bouton en réalisant un bouton qui appelle une connexion ou déconnexion selon l’état à cet instant : déconnecté ou connecté à l’aide d’une variable booléenne « connecte » (qui peu se traduire par « suis-je connecté ? »).

La procédure appelée lors du clic sur le bouton Connexion / Déconnexion

- La procédure « Appel_connexion » dans le module intègre l’appel de la procédure « Horloge » et initialise la variable start avant de lancer la connexion. Une subtilité s’ajoute à l’activation de la connexion, c’est la procédure « Demarrage ».

Procédure « Demarrage » qui s’exécute lors d’une connexion

- Cette procédure permet d’éviter l’actualisation automatique de l’ensemble des dernières coupes lors de la connexion pour deux raisons principales :

• Par soucis de temps car une actualisation de toutes les lignes est un peu longue et laisse croire à un bug lors de l’exécution de la feuille de calcul.

• Pour une plus grande efficacité d’utilisation car la mise à jour de la base de données ne se fera

pas non plus et on évite ainsi les doublons si une connexion a récemment été effectuée.

- Lorsque l’utilisateur souhaite lire manuellement la dernière coupe sur une ligne de production, il suffit de cliquer sur le bouton « Lire » correspondant, ce qui appelle la procédure « Lecture » correspondant à la ligne de production.

Page 21 / 40

Cette procédure « Lecture » affiche :

• la date, • la longueur programmée, • la longueur réelle • le diamètre.

Ces informations sont directement extraites des variables dans Kepserver. Je récupère également :

• l’heure à laquelle la coupe a eu lieu, • la durée de fabrication de la bobine, • le numéro de la coupe (équivaut au numéro de la bobine).

Comme ces informations sont indépendantes de Kepserver j’ai recherché d’autres solutions.

- Le numéro de coupe existe sur une partie du nom d’un fichier créé au moment du commencement d’une bobine. De plus, ces fichiers sont présents en nombre inconnu, souvent par centaine. Pour effectuer la lecture de l’ensemble des noms de tous les fichiers présents à l’intérieur d’un dossier donné, j’ai utilisé la fonction « Dir », au départ avec le chemin d’accès au dossier souhaité :

- Ce nom de fichier est formaté de la manière suivante :

« Nontisse #5.Production Line.Station 1.SS 15 a 19.2010-05-25.13-41-09.57642-11.SSF » Chaque information est séparée par un point, ce qui nous intéresse dans ce nom de fichier sont les parties suivantes :

Première partie : 2010-05-25 représente la date de création de la bobine ;

Deuxième partie : 13-41-09 représente l’heure de création de la bobine ;

Troisième partie : 57642-11 représente le numéro de coupe de la bobine.

- Maintenant que sont listés les noms des fichiers sur le tableur, il faut extraire ces

informations par manipulation de tableaux et d’une fonction « Split » qui va découper une chaine au caractère souhaité, ici à chaque point. Le tableau « TCoupe » récupère ensuite pour chaque fichier les trois informations nécessaires à notre étude, tout en gardant un point entre ces parties :

La variable « nb_fichier_L5 » correspond au nombre de fichiers présent dans le dossier, calculé auparavant par une méthode similaire.

Page 22 / 40

- Il faut ensuite trier l’ensemble par date et heure à l’aide d’une comparaison qui s’exécute à l’intérieur d’une double boucle pour réitérer le cycle de comparaison autant de fois qu’il le faudra :

Tant qu’il y a un changement effectué au cours d’un tri deux-à-deux pour chaque fichier, la boucle « Do ... Loop » appelle à nouveau ce tri deux-à-deux sur la totalité de la liste : Le tri deux-à-deux s’effectue en partant du haut de la liste, les deux premières cellules sont vérifiées et triées par ordre croissant, ensuite la deuxième et la troisième sont vérifiées et triées et ainsi de suite jusqu’en bas de la liste.

- Lors d’une vérification de deux cellules, le tri n’est pas forcément effectué si les deux cellules sont en ordre. En revanche si lors d’une vérification un tri sur deux cellules est effectué, une variable fin_tri prend 1 comme valeur. - Si la variable fin_tri est à 1, un nouveau tri deux-à-deux sur la liste entière est appelé, c’est lors de ce nouvel appel que cette variable reprend la valeur de 0.

- Par contre, si lors d’un tri deux-à-deux sur la liste aucune vérification n’a abouti à un tri sur deux cellules, la variable fin_tri reste à 0, c’est ce qui détermine la fin du tri et la condition de sortie de la procédure.

- Une fois les coupes triées, je les affiche sur la feuille de calcul par une simple boucle « For » dans l’ordre croissant de création. Pour récupérer le numéro de coupe correspondant à la dernière bobine terminée, il suffit juste d’extraire le numéro de l’avant dernière coupe. La dernière coupe que listée correspond à la bobine en cours de production. De la même manière, par un « Split(Derniere_coupe, ".") », je récupère à l’affichage la troisième partie qui correspond au numéro de coupe.

- En ce qui concerne la récupération de l’heure, elle pourrait simplement s’effectuer par la récupération et un calcul numérique sur une variable correspondante sur Kepserver, mais le résultat qu’il en sort est un nombre entre 0 et 1 correspondant respectivement à 0h et 24h. Microsoft Excel reconnaît ce format et le converti automatiquement au format horaire, mais lors du transfère dans la base de données, ce format d’heure ne change pas et on se retrouve avec un nombre inférieur à 1 contenant huit chiffres après la virgule. C’est donc par un procédé d’extraction et de concaténation que je récupère l’heure dans un format plus conventionnel tel que « hh:mm:ss ».

Page 23 / 40

- Pour le calcul de la durée, je récupère l’heure de démarrage de la dernière coupe (correspondant à l’heure de début de la dernière coupe) en la soustrayant à l’heure de démarrage de la coupe en cours (correspondant à l’heure de fin de la dernière coupe). Pour extraire l’heure de départ et de fin, j’utilise respectivement le tableau « TDerniere_coupe » et « TCoupe_encours » correspondant aux deux derniers fichiers listés, puis j’en extrais les deuxièmes parties.

- Les parties heures, minutes et secondes récupérées sont séparées par des tirets. Pour obtenir le format souhaité je concatène les heures, minutes et secondes séparées de deux points « : ».

- Un cas particulier : la dernière coupe à eu lieu avant minuit, alors que la coupe en cours a commencé après minuit, il y aura une confusion lors de la soustraction. Ce cas est envisagé et contourné ici par un décalage de l’heure de début de la coupe en cours de 24h, donc + 1 en décimal. - L’affichage final des données termine cette procédure :

- J’affiche respectivement :

• La date de la coupe, correspondant à Values(1) au sein du tableur, • L’heure extraite précédemment, • La durée extraite précédemment, • Le numéro de coupe par extraction de la troisième partie du tableau « TDerniere_coupe », • La longueur programmée, correspondant à Values(3) au sein du tableur, • La longueur réelle, correspondant à Values(4) au sein du tableur, • Le dernier diamètre, correspondant à Values(5) au sein du tableur.

Les noms des valeurs de la ligne 5 au sein du tableur :

Page 24 / 40

- Pour récupérer le moment ou une bobine est terminée et effectuer la lecture automatique, des variables « heure_rafraichissement » correspondant à chacune des lignes au sein de Kepserver changent lors d’une coupe (la déclaration de ces variables en contact de Step7 est consultable en annexe page 39/40). C’est à l’aide de la procédure « DataChange » qui va lire en permanence ces variables que je vais donner une condition si elles venaient à être modifiées. Cela annonce une coupe, c’est-à-dire une bobine qui vient de s’achever. Cette vérification s’effectue grâce à une comparaison avec une variable au sein de Visual Basic.

Condition d’exécution si une coupe a lieu sur la ligne 5

- On peut remarquer que je prends la précaution d’attendre deux secondes afin d’éviter tout conflit lors de la réception des données et de s’assurer que les données et les fichiers ne soient plus sollicités ou en cours de modification.

- Sans oublier d’ajuster la variable de rafraichissement au sein de Visual Basic, j’appelle

ensuite la procédure « Lecture_Click » correspondant au clic sur la ligne de production correspondante, vue précédemment.

- Lorsque la procédure « Lecture_Click » est achevée, la procédure « DataChange » effectue la mise à jour sur la base de données.

Exemple d’informations contenu dans la base de données pour la ligne 5

Page 25 / 40

Pour terminer, j’appelle la procédure « Demande_reconnexion » au sein du module général ( ) qui doit effectuer une déconnexion puis une reconnexion. En réalité à l’intérieur de la fonction « DataChange », il ne peut y avoir une procédure appelant directement une connexion ou une déconnexion car cela provoque une erreur et un blocage. La solution trouvée consiste à mettre une variable booléenne « reconnection » à Vraie lorsque l’on veut se reconnecter :

- La procédure « Horloge » va lire cette variable en permanence, dès que celle-ci passe à 1, cette procédure effectue une déconnexion et ensuite une connexion :

- Une fois la connexion achevée, le document se remet à l’état de « connecté », en attente d’une nouvelle coupe ou d’une action manuelle de l’utilisateur. - Quelques mesures de préventions ont été mises en place lors de la fermeture du document : la procédure « auto_close » contient les informations à exécuter lors de la fermeture du fichier, elle doit être placée dans le module général comme ceci :

Procédure appelée lors de l’arrêt du programme

- Ici cette fonction permet de stopper l’horloge et de déconnecter Kepserver si l’utilisateur oublie de se déconnecter, donc de ne pas créer de conflit avec Kepserver lors de la prochaine ouverture d’un fichier.

Page 26 / 40

- Ce fichier contient au final pour l’utilisateur :

• Quatre tableaux sur la même feuille correspondant aux quatre lignes de production • Les valeurs lues sur Kepserver • Un bouton Connexion/Déconnexion, les boutons Lire et Effacer pour chaque lignes • Les informations de supervision.

Les tableaux de données : Informations

Bouton Connexion/Déconnexion

à Kepserver

Valeurs lues sur Kepserver

Identifiants BDD

Boutons Lire et Effacer, pour chaques lignes

Page 27 / 40

4. Recyclage du non-tissé en excès (Secteur Erema.xls)

- Ici la connexion n’a pas besoin d’être établie en permanence, le but étant de récupérer les valeurs à la fin de chaque poste : les données du matin sont récupérées à 13h, les données de l’après-midi à 21h et les données de la nuit et total sont récupérées à 5h le matin. De la même manière, j’ai placé une horloge qui permettra, lors du franchissement de l’un de ces horaires, de déclencher la mise à jour correspondante. Le programme que j’ai réalisé lit en permanence l’heure. Les conditions de mises à jour sont :

• Après 5h, effectuer la mise à jour de la nuit précédente, • Après 13h, effectuer la mise à jour du matin, • Après 21h, effectuer la mise à jour de l’après-midi.

- Si rien n’est ajouté à ce programme, lors de l’ouverture du fichier après 13h, l’horloge détecte que 5h et 13h sont passés et voudra effectuer plusieurs mises à jour. Pour contourner cela je fais appel à la procédure « auto_open » afin d’initialiser deux variables booléennes « matin_ok » et « aprem_ok », qui traduisent si le matin ou l’après-midi ont déjà été mis à jour sur la base de données ou non. Pour la nuit, une condition de date suffi.

Procédure « auto_open » appelée automatiquement à l’ouverture du fichier

- A l’ouverture du fichier et selon la prochaine actualisation, j’initialise la date : les trois postes tournent sur un cycle de 24h qui commence à 5h et qui finit le lendemain à la même heure. Après 5h, forcément la prochaine actualisation à 13h concernera les valeurs du matin donc du jour même, mais avant 5h, la prochaine actualisation s’effectuera à 5h et concernera la nuit et le total correspondant aux valeurs de la veille. Ensuite, j’appelle simplement la procédure horloge et le cycle d’attente est en marche. La fonction horloge permettra ici de définir les conditions d’heure de lecture selon le passage à 5h, 13h ou 21h.

Page 28 / 40

La procédure « Horloge » et ses conditions de mises à jour automatique

- Une liste de commentaires explique selon l’heure franchie l’appel de la lecture des valeurs, c’est-à-dire l’actualisation des valeurs pour le jour utile. Cette procédure « Lecture » n’a rien de particulier, si ce n’est qu’elle va regarder le jour à actualiser par la fonction « weekday(Now()) » qui donne simplement le jour de la semaine. De plus, les données récupérées ayant huit chiffres après la virgule, j’utilise la fonction « Format » de manière à arrondir les valeurs à deux chiffres après la virgule :

- On aperçoit ensuite l’appel d’une procédure selon le poste (Apres_midi, Matin ou Nuit). Cette procédure est en réalité la mise à jour de la base de données, avec comme petite astuce sur la procédure « Nuit » qui est appelé à 5h : la mise à jour des valeurs totales de la veille.

Procédure « Nuit » : mise à jour de la base de données lors du franchissement à 5h

Page 29 / 40

Exemple de la base de données remplie sur 48h

- On remarque que le champ id-Erema contient un identifiant unique, qui est définit en tant que clé primaire. La date correspond aux valeurs du poste, ensuite les valeurs sont simplement ajoutées par la fonction « INSERT INTO ». - Dans la procédure « Horloge », je termine le corps d’une condition par la mise à jour des valeurs sur la feuille de calcul permettant de faire savoir à l’utilisateur le statut de celle-ci et la prochaine connexion :

- La feuille se remet alors en état de connexion automatique en attente d’une connexion manuelle ou de la prochaine heure de connexion.

Copie d’écran de la feuille de calcul du secteur Erema (Recyclage) aboutie

Le tableau de données :

Identifiants unique pour la BDD

Informations de supervision Valeurs lues

sur Kepserver

Actions spontanées possibles

Page 30 / 40

5. Installation d’un variateur pour moteur à courant continu

- J’ai également eu l’opportunité durant deux semaines, de participer à la mise en place d’un variateur de moteur à courant continu de type Siemens, datant de 1992. C’est un variateur de courtant maximum en sortie de 90 Ampères et de courant d’induit maximum de 10 Ampères. Le moteur commandé est destiné à faire tourner une vis sans fin, chauffé à 240 degrés, l’ensemble est appelé « extrudeuse lisière ». Cet ensemble permet de transformer et de réinjecter directement les deux extrémités de la bobine dans le processus de fabrication :

Lisières des bobines extraites et aspirées dans un conduit doté d’une soufflerie

Les lisières sont directement acheminées dans l’extrudeuse lisières :

Lisières injectées dans l’extrudeuse

Lisières

Transport lisières

Voile de non-tissé

Page 31 / 40

La mise en place de ce variateur s’est déroulée en plusieurs étapes : 1. A l’aide du schéma de câblage existant de l’armoire électrique et de la documentation technique du variateur, il a fallu concevoir un nouveau schéma de câblage, à l’aide de See3000, consultable en annexe, page 36. 2. Sur le banc d’essai, j’ai câblé, paramétré et testé le variateur à l’aide de la documentation technique correspondante. Durant cette étape j’ai conçu l’ensemble des câbles nécessaires, j’ai conçu deux supports de bornier pour la partie commande et j’ai remplacé la carte mère qui était défectueuse. Voici le variateur et ses différentes parties :

1) Une carte mère

2) Une interface avec l’utilisateur, pour régler les paramètres et informer lors d’un défaut

3) Branchements de la partie commande

4) Branchements de la partie puissance

5) Trois relais de commande

6) Un bornier pour les connecteurs

3. Lorsque les tests ont été concluants, je me suis occupé de l’installation finale (cf. photo précédente). C’était ici en grande partie des travaux manuels : Perçage à l’intérieur de l’armoire électrique afin de fixer le variateur et le support du bornier, couper, dénuder et sertir les câbles. J’ai utilisé le schéma conçu précédemment afin de réaliser le câblage.

4. Enfin, la mise sous tension du variateur et le paramétrage adapté au moteur à courant continu à l’aide des informations relevées sur la plaque signalétique.

Plaque signalétique du moteur

- Tout n’a pas été réussi du premier coup, ni même le schéma final, mais lorsqu’une erreur se présentait j’ai recherché diverses solutions possibles afin de déceler l’origine du problème. Il y a par exemple eu quelques problèmes de branchement sur la partie commande lors de l’installation finale comme l’affichage de la vitesse et du couple. Un paramétrage plusieurs fois repris lors des tests ou encore une inversion de branchement de la dynamo tachymetrique.

Page 32 / 40

III - La finalité du projet

Mon envie de réussir et ma motivation m’ont permis de faire de mon mieux pour remplir les conditions demandées durant mon stage. Je souhaitais rendre un travail abouti et prêt à l’emploi à l’entreprise. La société Dounor avait besoin d’informations complémentaires concernant ses différentes consommations et productions afin d’optimiser sa chaîne de travail. A terme, ces fichiers Excel sont destinés à êtres exécutés en permanences depuis le serveur contenant Kepserver ainsi que la base de données. Grâce à ce projet, j’ai apporté de nouveaux outils qui vont désormais permettre à cette entreprise de récupérer :

- Le diamètre en fonction d’une longueur donnée sur la ou les bobines d’une production donnée.

- De manière automatique et régulière, les quantités de matières consommées sur chacune des quatre dernières lignes de production.

- De manière automatique les informations de l’ensemble des bobines produites lors de leur sortie sur machine.

- De manière automatique et régulière, l’ensemble des quantités et moyennes de produit recyclé pour chaque poste horaire.

Pour ces trois dernières possibilités, les données sont automatiquement retranscrites sur la base de données interne afin d’une part de conserver une traçabilité et d’autre part de constituer un historique de ces informations. Cette base de données est destinée à être exploitée par le service informatique afin d’extraire les informations et de les retranscrire sur l’application interne de Gestion de Production Assistée par Ordinateur (GPAO), par son développement via Windev. A terme, ce logiciel qui est consulté par l’ensemble du personnel de Dounor va permettre :

- De donner la possibilité à l’opérateur d’extraire un défaut sur une bobine : actuellement, l’opérateur est informé par ordinateur sur la nature et l’endroit lorsqu’un défaut est détecté sur une bobine. Selon sa nature et son importance et connaissant désormais le diamètre correspondant à la distance du défaut, l’opérateur peut extraire ce défaut par une coupe transversale de la bobine.

- De contrôler les quantités de matière première (granulés de polypropylènes et produits additifs) entrantes et sortantes.

- Au service qualité d’avoir à disposition une banque de données d’informations sur la totalité des produits sortants, pour consulter les informations dans le cas d’un éventuel litige. Ces données permettront également d’optimiser la production lors des différentes modifications de paramétrage ou lors de l’installation d’un nouveau matériel.

- De pouvoir réaliser des statistiques concernant le pourcentage de matière recyclé et injecté au sein des différentes lignes de production, donc d’estimer la quantité de produit source pur du voile de non-tissé. Ces données permettront notamment d’optimiser la production.

Page 33 / 40

IV - Conclusion

Cette première expérience professionnelle dans le domaine industriel m’a apporté une certaine constance de travail et de l’autonomie, car j’ai régulièrement était livré à moi-même et malgré cela, il fallait que je préserve ma motivation à avancer et que je persévère pour trouver les solutions à chaque problème posé. J’ai également, autant que possible, tenu à rendre une ou plusieurs finalités fonctionnelles à la fin de chaque journée, ce qui m’a permis de maintenir un rythme dans mon travail. Cette expérience m’a également montré l’esprit d’entreprise, c’est-à-dire le respect d’un règlement de sécurité intérieur, l’entraide entre coéquipier et le partage des différentes ressources matérielles et d’informations au sein de l’usine.

J’ai pu mettre en application mes connaissances acquises grâce aux cours de M. Deleruyelle et M. Boussekeyt, qui m’ont enseigné les bases sur Visual Studio et Visual Basic . Ces connaissances m’ont aidé au départ à prendre en main Visual Basic for Application (VBA), le langage de programmation implanté au sein de Microsoft Excel. Les méthodes dont je me suis souvenu m’ont permis entre autre de ne pas être submergé, mais au contraire de ne pas perdre de temps à comprendre le principe de cette programmation. Grâce à ces cours, j’ai facilement compris la logique de programmation sur des exemples lors de mes diverses recherches sur Internet.

J’ai également approfondi mes connaissances en communication réseau, tant Ethernet que Profibus, qui est également beaucoup utilisé dans l’usine. La technologie utilisée au sein de l’entreprise Dounor est exclusivement du Siemens, ce qui m’a permis d’apprendre un autre langage d’automate que Ladder : le contact de Step7. J’ai réussi à me familiarisé relativement facilement aux bases de celui-ci, dans un premier temps grâce à mon tuteur Pierre DENOEUD, qui m’a montré et expliqué quelques exemples, mais également aussi grâce à une logique de programmation en automatisme acquise en ARS, avec M. Pomorski.

L’opportunité pour moi de câbler un variateur s’est présenté, ce qui m’a permis d’apprendre l’aspect pratique de ce que j’ai pu étudier en électrotechnique avec M. Idir, telle que l’étude d’un moteur à courant continu, mais aussi la lecture d’une documentation technique et de schémas électriques.

Je suis réellement satisfait d’avoir effectué mon stage au sein de l’entreprise Dounor, c’était une expérience très enrichissante, qui m’a fait découvrir le monde industriel de par sa productivité mais aussi et surtout par les technologies récentes et variées qui sont utilisées et qui ont beaucoup attiré ma curiosité. J’ai remarqué à quel point chaque membre de l’équipe électrique dans lequel j’étais engagé, possèdent une grande polyvalence, c’est un aspect qui me réjouit de savoir que l’on peut enrichir ses compétences et diversifier son utilité, même en ayant un diplôme orienté sur une compétence particulière.

Mon but durant ce stage fut d’apporter des solutions concrètes et fonctionnelles sur des sujets à améliorer. Je n’ai pas vraiment eu de planning prévisionnel, le travail m’a été expliqué et demandé au fur et à mesure de mon avance et des besoins de l’entreprise. C’est avec le temps que j’ai réellement cerné ma fonction, j’ai donc pu peu à peu affiner ma réflexion sur le travail à effectuer, ce qui m’a amené régulièrement à reprendre un travail que je pensais abouti afin de répondre le mieux possible aux attentes.

Page 34 / 40

Annexes

Article sur Dounor paru dans « La voix du nord » en mars 2010

Pupitre de fonctionnement régit par le variateur installé

Page 35 / 40

Schémas électriques du précédent variateur

Page 36 / 40

Schémas électriques du variateur nouvellement installé

Dynamo tachymetrique Moteur

Partie puissance

Excitation séparée

Indicateur de couple Compte tours

Relais

Page 37 / 40

Schéma de principe d’une tête extrudeuse type Spunbond

Schéma de principe d’une tête extrudeuse type Meltblown

Page 38 / 40

Procédé de fabrication de la Ligne 7 type SS « Double Spunbond »

Procédé de fabrication de la Ligne 8 type SXMMS « Spunmelt »

Page 39 / 40

Afin de récupérer les heures et dates des coupes sur le fichier des relevés d’informations lors d’une coupe (troisième sujet), j’ai programmé en langage contact de Step7 les variables permettant de récupéré via Kepserver ces informations.

Copie d’écran du programme réalisé en contact permettant de récupérer la date et l’heure de coupe :

Récupération de la date et de l’heure en continu dans la variable temporelle #date_heure_coupe

Récupération de la date de la coupe dans la variable DB4.DBW4

Fonction extraction de la date

Fonction extraction de l’heure

Récupération de l’heure de la coupe dans la variable DB4.DBD0

Lors de la coupe, le contact devient passant

Page 40 / 40

Visualisation des variables déclarées

Afin de consulter les codes sources au complet des quatre sujets informatique, les fichiers sont disponibles à l’adresse suivante :

http://freddobjectif.free.fr/stage-quentin-defossez/