Ce projet de bras robotisé vous est présenté par MANTOT Thomas apprenti en génie électrique et informatique industriel chez ACTEMIUM ainsi que ALLENBACH Timothée aussi apprenti en génie électrique et informatique industriel chez CLEMESSY Nucléaire.

Abstract

Dans le cadre du projet de fin de DUT GE2I, nous avions la possibilité de choisir notre projet personnel. Nous étions parti en premier lieu sur l’idée d’une station météo piloté en Raspberry, mais M.Vigne nous a proposé une autre idée qui nous a finalement plus attiré. Cette dernière étant un bras robotisé de type lego à 3 axes, que l’on doit piloter avec une Raspberry et par une interface web.

Présentation du dossier

Tout d’abord une présentation générale du projet sur lequel nous avons travaillé, le principe et but de celui ci.

Puis par la suite une présentation plus ciblé du matériel utilisé, en commençant par le bras et les éléments associé à celui ci, puis par les cartes électroniques qui ont été utilisé.

Ensuite, un point sur le cahier des charges que nous avons établi au lancement du projet, suivi d’une partie sur la gestion du projet.

La parti sur la gestion du projet comprend:

• un diagramme de Gantt
• les étapes initialement prévu
• les divergences sur le planning

Pour finir sur la plus grande parti qui est le déroulement du projet en lui même.

Nous présenterons par étapes les différentes réalisation effectué durant le projet qui sont:

Identification des câbles et des entrées/sorties de la PiFace

• Trouver une solutions pour piloter les moteurs à double sens.
• Tester les contacteurs et moteurs.
• Ajout du module de 8 relais.
• Câblage.
• Installation des pilotes PiFace pour la Raspberry
• Commande des deux relais via buttons poussoir.
• Piloter les 8 relais avec les sorties à collecteurs ouvert.
• Programmation Python.
• Multi-tâche python
• Interface web
• Esthétique

Pour finir par un bilan du projet dans lequel nous présentons la finalisation de ce dernier tout en donnant quelques points que nous avons retenue.

Et bien sure les remerciement envers les personnes qui nous ont accompagnée tout du long de cette période.

 

Présentation du Projet

Le projet nous a été confié par M.Vigne. Il est question d’un bras de type Lego avec une pince au bout pour le déplacement d’objet entre deux points.

Pour piloter celui-ci nous avions à la base une Raspberry Pi model B et une carte PiFace Digital, permettant de contrôler des relais et des fin de courses sur le bras. Il y a également sur le bras 4 moteurs qui permettent alors des déplacements sur 3 axes.

Nous avons alors ajouté plusieurs éléments pour finaliser le projet et aller jusqu’au but de celui ci.

Le but du projet étant de programmer la Raspberry pour contrôler les moteurs et via une interface web faire déplacer des objets entre deux point grâce à la pince amovible.

Nous avons du rajouté plusieurs éléments pour compléter le projet:

• une alimentation 24Vdc
• une carte de 8 relais
• une nouvelle carte Raspberry Pi 3 (à la place de la model B)
• une boite pour placer les éléments électronique (à but esthétique)

Nous avons du rajouter la carte de 8 relais carte nous ne pouvions pas contrôler les 4 moteurs avec seulement les deux relais d’origine placé sur la PiFace. Puis nous avons du remplacer la Raspberry par une plus puissante équipé d’un module wifi pour pouvoir contrôler le bras via une interface web accessible sur smartphone.

 

Présentation du matériel

Le bras robotisé et ces accessoires

Composé de deux moteurs 3A/24V N/L 5500RPM (soit environ 575,959 rad/s) présents pour les déplacements rotatif (droite/gauche) et verticale (bas/haut).

 

Deux autres petit moteurs 24Vdc qui sont là pour le déplacement avant/arrière et l’ouverture/fermeture de la pince.

8 contacts inverseurs qui ont deux utilisations différentes.

• La première utilisation étant des fins de course pour stopper les moteurs dans un sens de fonctionnement.
• La deuxième manière d’utiliser les contacts inverseurs est d’en faire des comptes tours pour savoir à quel moment stopper le moteur dans l’autre sens de fonctionnement.

 

Il y a également une alimentation 24V qui est là pour alimenter les relais et moteurs contrôlant le bras.

 

Les cartes électroniques

Initialement deux cartes électroniques étaient fourni.

Raspberry Pi model B

• Processeur ARM1176JZF-S (ARMv6) 700 MHz Broadcom 2835
• 256Mo de RAM
• 2 Sorties vidéo: composite et HDMI
• 2 ports USB
• Prise pour alimentation Micro-USB
• lecteur de carte Micro-SD
• un port réseau Fast-Ethernet

 

PiFace Digitale

• Deux relais en sortie
• 8 sorties à collecteurs ouverts
• 8 entrées digitale
• 8 LED
• 4 switchs
• un émulateur et simulateur graphique
• programmation en python, scratch et C
  

 

 Une carte de 8 relais

Raspberry Pi 3

• GPIO 40 broches
• 1 GB de RAM
• 4 ports USB 2.0 et meilleur comportement en cas de surcharge
• port HDMI
• port Ethernet
• prise jack de 3,5mm
• une interface caméra
• une interface écran
• micro SD
• meilleur circuit audio
• un processeur 1.2GHz 64-bit quad-core ARMv8
• une puce Wifi 802.11n
• Bluetooth 4.1

La Raspberry Pi 3 est là pour remplacer la 1 car elle ne suffisait plus pour l’utilisation prévue. Elle manquait de puissance et ne supportait pas l’interface web, or la Raspberry 3 apporte le wifi embarqué et un meilleur processeur, ce qui permet de commander le bras via un smartphone sans qu’il y est de lag à cause des calcul et de l’interface web.

Cahier des Charges

Fonctions	Contraintes	Niveau
Déplacer objet	•Degré de liberté •Déplacement maximal •Ouverture pinces •Environnement	•3 (RY, TX, TY) •RY : 360° /  TX : 12cm / TY : 19cm •Max : 4cm / Min : 2,6cm •Sec, température « humaine », surface plane.
Commande	•Accès via smartphone •Gérer les positions •Double sens •Positions maximales •Documentation PiFace	•Interface wifi •Logiciellement •Logiciellement •Fin de course et compte tour •Recherche personnel
Supervision	•Compte tour •Etat robot •Commande	•Calcul des butées (logiciellement) •Page web (HTML, PHP & Python) •Page web (HTML, PHP & Python)

 

Gestion du Projet

Au début du projet nous avons du réfléchir à la démarche à suivre pour ce projet. Nous avons donc établi à première vue les taches à faire et le temps qu’elles prendraient. Avec cela nous avons pu définir un planning prévisionnelle du projet pour nous aider à organiser les séances à venir. Bien sure celui ci à été revu plusieurs fois car des étapes on du être rajouté et certaines auront pris plus de temps que initialement prévue.

Diagramme de Gantt

 

Les étapes du projet initialement prévue

Voici les étapes initialement prévu:

• Identification des câbles et des entrées/sorties de la PiFace
• Trouver une solutions pour piloter les moteurs à double sens
• Tester les contacteurs et moteurs
• Câblage
• Installation des pilotes PiFace pour la Raspberry
• Commande des deux relais de la PiFace via buttons poussoir.
• Programmation Python
• Codage page HTML et PHP.
• Programmation interface web
• Esthétique

Les divergences sur le planning

Malheureusement il y a eu quelques problèmes et certaines taches ont pris plus de temps, ce qui à engendré une divergence sur le programme initiale.

• Tout d’abord après avoir cherché à commander les 4 moteurs via les deux relais de la PiFace nous avons du changer d’idée, car seulement deux relais ne suffisait pas:
  • Ajout du module de 8 relais.
  • Piloter les 8 relais avec les sorties à collecteurs ouvert.
• Le multi-tache: Il a fallu trouver la solution pour pouvoir agir en permanence sur le bras. Pour pouvoir donner en temps réel des ordres au bras, il a fallu trouver un code qui permette au programme de constamment lire la variable « sens » (permet de donner les ordres de déplacement) tout en exécutant le programme, donc de faire le mouvement demandé.
• L’interface web : Dans ce projet nous avons appris le python et donc du trouver une solution pour faire communiquer une page web avec du python et récupérer des informations en temps réelle. Le problème à été de pouvoir appuyer sur un bouton de la page web qui exécuterai un bout du programme Python (celui correspondant au sens demandé). Pourvoir faire une passerelle entre les deux languages de programmation n’a pas été une tâche facile à effectuer. Il y a donc eu obligation de changer de procéder pour permettre l’interaction entre les deux systèmes.

Par la suite nous présentons un développement détaillé des actions effectué et des problèmes/solutions encouru durant le projet.

 

Déroulement

Voici les étapes du projet que nous développeront par la suite:

• Identification des câbles et des entrées/sorties de la PiFace
• Trouver une solutions pour piloter les moteurs à double sens.
• Tester les contacteurs et moteurs.
• Ajout du module de 8 relais.
• Câblage.
• Installation des pilotes PiFace pour la Raspberry
• Commande des deux relais via buttons poussoir.
• Piloter les 8 relais avec les sorties à collecteurs ouvert.
• Programmation Python.
• Multi-tâche python
• Interface web
• Esthétique

Identification des câbles

Identification des câbles par test de continuité entre les deux extrémités. Ce qui a permit d’établir un schéma de la nappe des câbles suivant:

Pour ce qui est de l’identification des entrées/sorties de la PiFace, la documentation technique de la carte a été recherché sur internet et prise en compte pour le reste de la réalisation du projet.

Piloter les moteurs à double sens

Pour faire circuler la tension au seins des 8 relais il a fallut réaliser des ponts :

La commande des deux relais permet alors d’inverser la tension afin d’avoir un double sens de rotation.

Cela fonctionne sur le principe ci dessous:

Voici le schéma électrique interne des relais, donnée dans la documentation technique de la PiFace. Le fonctionnement du module de 8 relais est le même que celui là. Le principe est que en activant un relais, cela active la petite bobine interne ce qui va avoir comme conséquence de faire commuter le contact.

 

Le schéma ci-dessus représente le fonctionnement de branchement des relais pour faire fonctionner un moteur dans un sens de rotation.

Sur le schéma est représenté le mode de fonctionnement dans un sens de rotation, pour effectuer l’autre sens il suffit d’inverser les contacts. C’est pour cela qu’il faut que les relais soient commander de manière complémentaire. Activer le relais 0 et désactiver le relais 1 et inversement pour l’autre sens.

Tester les contacteurs et moteurs

Après identification, il y a eu une phase d’essai des contacteurs et des moteurs.

• Pour les contacteurs, nous avons tester la bonne commutativité des contact en réalisant des test de continuité entre les bornes 1 et 3. Tout d’abord on vérifie qu’il y a bien une absence de continuité. Puis on effectue une pression sur le bouton pour faire commuter le contact et on vérifie alors qu’il y a bien une continuité. Cette démarche a été effectué pour les 8 contacts inverseurs du bras.
• Pour les moteurs, nous avons tester le bon fonctionnement de ceux ci dans les deux sens avec l’alimentation 24V. Tout d’abord, mise sous tension entre les deux bornes et vérification que le moteurs tourne correctement. Ensuite le même test en inversant les bornes positive et négative et vérification que le moteur tourne correctement et cela dans le sens inverseur. Cette démarche a été effectué pour les quatre moteurs du bras.

Ajout du module de 8 relais

Remplacement des deux relais de la PiFace par un module de carte électronique à 8 relais acheté sur internet. Le module à été branché sur les sorties à collecteurs ouvert. Après installation, il y a eu une phase de test des 8 relais pour être sûre qu’ils commutaient correctement. Pour pouvoir piloter les moteurs à double sens, il a fallu après le branchement à la PiFace, refaire le même branchement que cité plus haut et cela avec les 4 moteurs du bras. Le principe de branchement étant le même il a juste fallu recopier le 24V et le 0V sur tout les relais.

Câblage

La phase de câblage à du être étalé sur tout le long du projet car même si elle aura été la plus grande au début, il aura fallu la refaire et la modifier plusieurs fois durant la période de réalisation du projet.

Cette phase à consister à connecter touts les moteurs au module de 8 relais et les contacteurs au entré numérique de la PiFace (comme ci dessous).

Le branchement des moteurs sur les relais à été fait pour que les sorties à collecteurs ouvert ci-dessous correspondent aux branchements des sens de fonctionnement du bras voulu. Les chiffres correspondant au numéro des pins utilisé mais aussi au numéro du relais qu’il faut activer pour effectuer l’ordre qui lui est associé.

Le branchement des entrées numérique à été effectué sur le modèle présent ci-dessous:

L’ensemble des contacts inverseurs est câblé sur les entrées, chaque bornes 3 des 8 contacts sont reliés ensemble sur la borne GND de la PiFace. Ensuite chaque bornes 1 de chaque contact est relié à une entrée numérique qui lui est associé.

Il aura fallu plusieurs fois rallonger les câbles avec des nappes acheter sur internet. De plus pour une question esthétique nous avons entouré les nappes de câbles avec du scotchs noir spécifique au câbles électrique.

Installation des pilotes PiFace pour la Raspberry

Avant d’installer les pilotes il a fallut installer le système d’exploitation Raspbian pour la Raspberry, c’est une version de Linux Ubuntu) optimisé pour la Raspberry. Ensuite, nous avons installé la carte PiFace sur les GPIO de la raspberry, une fois ceci fait il a fallut mettre à jour la Raspberry pour qu’elle récupère tous les packages en ligne avec la commande sudo apt-get update -y (sudo = autorisation administrateur) cela permet de lister les mises à jour disponible, et enfin la commande sudo apt-get upgrade -y pour installer les mises à jours. Le paramètre « -y » permet d’éviter la confirmation d’installation.

Commande des deux relais via buttons poussoir

Le premier programme effectué était la commande d’un relais via un bouton poussoir disponible sur la carte PiFace. Pour cela il faut créer un programme en Python et donc apprendre ce langage.

Le programme commence par  #!/usr/bin/env python pour indiquer où se situe le moteur d’exécution python sur la Raspberry. Ensuite il faut importer les librairie télécharger via la mise à jour : import piface.pfio as pfio et enfin initialiser cette librairie : pfio.init().

Une lecteur d’entré ce fait via la fonction : pfio.digital_read( 0 ), où le chiffre est le numéro de l’entré. Écrire dans un relais s’effectue de cette façon : pfio.digital_write( 1, 1 ) => On met le relais 1 en « ON ». pfio.digital_write( 1, 0 ) => Etant la commande pour mettre le relai 1 en « OFF ».

Différents petit programme pour recevoir les informations des contacteurs ou d’envoyer des ordres via les sorties à collecteur ouvert, mais aussi des petit bout de code pour effectuer un comptage de tour… ont été mis en place afin de s’entraîner à coder en Python et à comprendre sa manière de communiquer. Cela à permis de prendre en main la librairie de PiFace et aussi le language Python.

Piloter les 8 relais avec les sorties à collecteurs ouvert

Après avoir pris en main le language  nous avons codé les fonctionnement des 4 moteurs avec les 8 relais. Pour cela nous avons également enlever les jumper 5 et 6 pour éviter que les deux relais de la Piface s’active en même temps que les deux relais des deux premières sortie à collecteur ouverts, car les codes d’activation pfio.digital_write( 1, 1 ) et pfio.digital_write( 2, 1 ) activent les deux relais de la carte tout en envoyant la commande dans les deux premières sorties.

Le branchement des sorties vers les relais correspondant et donc vers les moteurs associé a été donné plus haut, voir chapitre « câblage ».

Programmation Python

La programmation Python à été avec l’interface web(programmation PHP, CSS, Javascript) la plus grosse parti du projet. C’est pour cela que nous ne présenteront pas l’intégralité du code ni pour le Python ni pour l’interface web qui est traité plus tard.

Ce qui est à retenir est que le language n’était pas connu au début et a eu comme conséquence un apprentissage long et méthodique de celui ci tout au long de cette phase de réalisation. Il a fallu passer par plusieurs petit code de test pour pouvoir construire au fur et à mesure le code entier du programme souhaité. Plusieurs fois il a été modifié pour des raisons diverses et variés.

Tout d’abord, on cherche l’information dans la variable sens qui correspond à une chaîne de caractère présente dans un fichier texte. Cette chaîne de caractère étant définit par le bouton de la page web qui serai actionné. Le scrutage du Python va donc constamment regarder la valeur inscrite dans le fichier texte et la reporter dans la variable sens et ensuite faire de même sur cette variable.

C’est là que suivant la valeur de la variable on exécutera des ordres différents. Comme ci-dessus on prends l’exemple des mouvements avant/arriere.

Ci-dessous est présenté une partie du code qui correspond au fonctionnement des sens avant/arriere du bras.

• La première ligne faisant entrer dans le « if » si la condition est vrai. Imaginons que elle l’est tout au long de la simulation.
• La deuxième ligne donne à la variable etatEntree3 la valeur contenu dans l’entrée du pin 3 qui est (grâce au schéma vue plus haut) le Cpt tour M3 , le moteur M3 étant le moteur associé aux déplacements avant/arriere. La valeur est soit 0 ou 1. Prenons 0 pour l’instant.
• La ligne pfio.digital_write(5,1) actionne le relais 5 qui va faire tourner le moteur dans le sens avant.
• Ensuite on compare les valeurs de etatEntree3 et dernierEtat3 (qui elle est initialisé à 0 au début du programme) étant les même on ne rentre pas dans la boucle. Et on recommence à la deuxième et cette fois la valeur est à 1 (Il faut savoir que le programme est lu extrêmement rapidement et peut être donc lu plusieurs fois sans que la valeur de l’entrée est encore pu changer). On garde l’activation du moteur (car tant que on n’envoie pas la demande de désactivation du relais, il reste activé).
• Cette fois les valeurs des deux variables sont différentes et on peut entrer dans le if  mais etatEntree3 est différent de 0 donc on n’incrémente pas la variable cpt_haut. Par contre on donne à dernierEtat3 la nouvelle valeur de l’entrée qui est 1 .
• Le compteur étant initialisé à 0 au début du programme la condition de valeur sur cette variable n’est pas vrai donc on remonte en haut.
• Si la valeur de l’entér n’etait pas encore changé et donc encore à 1 , cela ferai comme dans le premier cas et les valeurs des deux variables à tester serait la même car celle du dernier etat à été mise à 1 juste avant.
• Donc on imagine que la valeur de etatEntree3 est repassé à 0 .
• On entre dans la condition et cette fois ci dans la deuxième aussi, ce qui va donc incrémenter de 1 la valeur de cpt_haut.
• On remet la valeur de 0 dans dernierEtat3 et on revient donc dans le cas du début lorsque les deux variables était égale à 0.

On comprend donc que ce programme fait tourner le moteur dans le sens avant et incrémente le compteur du moteur sur front descendant de l’entrée. on peut faire la même simulation dans le cas où la valeur de etatEntree3 commencerai à 1. cela fonctionne de la même manière. Bien sur le programme sort de la boucle lorsque le compteur à atteint la valeur qui à été définie et remet le relais à 0 (pfio.digital_write(5,0)) . 

Le principe est le même avec le sens inverse qui est le sens arrière mais cette fois ci on décrémente sur front descendant. Et au lieu d’arrêter le moteur sur une valeur du compteur, elle est arrêté sur la valeur du fin de course lié à ce moteur. Il aurait été tout aussi possible de le faire sur la valeur du compteur atteignant 0. 

Ce principe de fonctionnement est le même sur tout les sens du bras excepté que les valeurs de limite ne sont pas les même. le cas de la rotation droite/gauche est spéciale car n’ayant pas de fin de course, la rotation est arrêté logiciellement dans les deux sens et on autorise une valeur du compteur négative.

Bien sure ce fonctionnement est possible seulement si la carte est assez puissante pour parcourir le code plus vite que la valeur de l’entrée puisse changer. Car sinon la valeur du compteur ne serai pas réel car le programme sauterait des fronts de valeurs de l’entrée. C’est aussi pour cela qu’il a fallu changer la carte, la première n’etait pas assez puissante pour faire tourner le programme en plus de l’interface web et donc n’arrivait plus à suivre une valeur correcte du comptage. Ce qui ne pose plus de problème avec la Raspberry 3 qui est beaucoup plus puissante.

Comme cité plus haut le programme scrupte en continue une valeur tout en exécutant le programme, c’est comme si il était à deux endroit au même endroit, il fait du Multi-tache. Ce bout de code permettant cela étant très important dans notre cas, il est détaillé dans la partie qui suit.

Multi-tâche python

Le plus gros problème du codage à été d’effectuer du Multi-tache. Le but était de pouvoir écrire en temps réel les différents sens de rotation en même temps que le programme s’exécute en arrière plan. La solution était de créer un thread et mettre dedans notre dialogue d’interaction.

Voici un exemple de thread, def est une fonction. Dans cette fonction on demande une interaction avec l’utilisateur en continue. Ensuite on déclare ce thread et on attache la fonction au thread. Puis enfin il faut mettre en start le thread pour qu’il s’exécute.

On comprend donc que le programme va constamment écrire « Entrez le sens:  » et tout en exécutant le programme va scruter l’information que l’on entrerai dans la variable sens, ce qui lancerai une autre action au niveau du programme et permettrai de changer de sens de déplacement sans attendre que le programme finisse la boucle correspondante au sens indiqué.

Interface web

Pour faire cette interface web il faut donc mettre en relation de code python avec une page web en HTML ou PHP.  Les premières étapes étaient de séparer chaque mouvement dans différents script python et d’exécuter ces script via un bouton en HTML. Cela n’était pas du tout fonctionnel car on perdais nos variable de comptage pour les différents axes. La bonne solution fût donc de modifier entièrement le code python et de ne plus fonctionner avec des variables mais avec un fichier texte. On va alors écrire dans ce fichier texte une chaîne de caractère, par exemple « bas », et le code python va scruter en continue ce fichier texte. Il va voir « bas » et l’écrire en variable interne, cette variable va permettre d’exécuter les « if » et donc d’exécuter les bons programme pour les bon moteurs.

Afin d’obtenir des informations en temps réelle de l’état du bras, il y a une exécution de petits script python pour les fin de courses pour obtenir leur état. Une interprétation du résultat en python affiche un logo vert ou rouge selon l’état. Enfin, pour obtenir les informations sur la page PHP on ajoute un script python qui va exécuter toutes les 500ms les petits script PHP qui vont exécuter le python.

Ci-dessous, le diagramme des liaisons et échanges d’informations entre les différents code de l’ensemble des programmes du projet:

 

Voici quelques exemples de code, qui permettent une meilleur compréhension de la manière d’on est structuré le programme de l’interface web.

Javascript :

 

Cette fonction javascript est exécuté toutes les 500ms, elle va simplement récupérer le contenu du fichier fc6.php et l’insérer dans une div HTML/CSS pour l’afficher sur la page web.

fc6.php :

Dans ce fichier PHP on va exécuter le fichier fc6.py qui est un fichier python qui retourne l’état d’un fin de course. En fonction du résultat retourné, le programme envoie l’information d’afficher soit un voyant vert ou rouge au Javascript.

fc6.py :

On arrive enfin au code python : Si l’entrée numérique est à 1 alors la console sort le texte « Activer », le PHP va recevoir ce texte et l’afficher pour donner l’état du fin de course.

On peut donc via ces trois fichiers présenté connaitre l’état d’un fin de course en temps réelle.

Esthétique

Pour rendre le tous plus jolie, une petite maison en lego à été conçu. Cela à permis de réunir la carte Raspberry Pi et et la PiFace, de plus un ventilateur de 80mm à été rajouter pour permettre à la Raspberry pi 3 de moins chauffer, la température étant passé de 80°C à 45-50°C.

 

 

Bilan

Le But du projet à été atteint, le bras arrive à ce mouvoir correctement lorsque l’on le commande via la page web que l’on peut voir ci-dessous.

En plus d’avoir afficher l’etat des fin de course des axes, nous avons rajouter les informations suivante:

• la date et l’heure (qui malheureusement ne sont pas correct car il faudrait refaire une mise à jour de la carte )
• l’état du robot ( si il fonctionnement ou pas)
• la température du CPU
• la mémoire disponible

Voici une petite vidéo de son fonctionnement:

De plus nous avons pu faire en sorte que les programmes ce lancent au moment de l’alimentation de la carte ce qui permet de contrôler le bras via le smartphone sans passer par l’interface clavier/souris/écran. Tout ce qu’il suffit de faire est de lancer la carte et de se connecter au réseau wifi de celle ci puis d’accéder à la page web de commande vue plus haut.

Il reste alors à contrôler le bras pour déplacer des objets qui sont dans sa capacité.

Nous avons également pensé à une amélioration futur qui pourrais être de rajouter un mode automatique sur un deuxième onglet de la page sur lequel on pourrait entrer des coordonner afin que le bras déplace seul un objet entre ces deux points, cela rapprocherai le robot d’un  modèle plus industriel tel que les bras robotisé automatisé dans les chaines de fabrication automobile.

Nous laissons ces possibilités à nos successeurs GE2I si cela leur convient de tenter l’aventure sur ce projet.

 

Remerciement

Nous remercions toute l’équipe pédagogique de l’IUT qui nous a soutenue et encourager à faire ce projet. Les professeurs ont su être présents lors des séances pour nous guider ou donner des pistes de réflexion afin de ne pas rester coincer. Ce la nous a permis d’avancer et de pouvoir finir le projet dans les temps tout en rajoutant quelques fonctions supplémentaires.

L’IUT nous a permis de réaliser ce projet grâce à son soutient logistique et budgétaire, elle a su nous épauler pour la participation à l’achat des cartes électronique et autres matériels. Sans le soutient de l’équipe pédagogique et de l’IUT nous n’aurions jamais pu réaliser un projet comme celui ci. Ils ont su nous donner la motivation et la détermination nécessaires à l’aboutissement de ce bras robotisé.

Ce projet nous a beaucoup apporté en connaissance sur différents domaines, tel que l’informatique, le web, l’électronique et la gestion d’un projet de A à Z. Nous saurons en faire bon usage et accordons énormément de gratitude envers les personnes qui nous ont suivi.