Automatic Soldering System Project
Sommaire
Placeur de composants sur PCB
Présentation du projet
Durant le début de l'été, nous avons eu l'idée de proposer un projet de soudure automatique. Ce projet avait pour but de concevoir un système permettant l'automatisation des soudures sur une carte électronique à composants traversants. Après des échanges avec le responsable des projet de 5éme année, M. Vantroys, nous avons finalement abandonné notre projet au profit d'un autre projet assez proche.
L'idée du nouveau projet est de proposer un système de Pick & Place de composants CMS sur une carte électronique sur laquelle de la crème à braser est préalablement déposée sur les pastilles. Pour mener à bien ce projet, nous avons été épaulé par M. Redon, M. Vantroys et M. Boé. En plus de nos encadrants école, nous avons travaillé en étroite collaboration avec M. Flamen, responsable du service électronique de Polytech Lille ainsi qu'avec M. Astori, enseignant en Conception Mécanique et responsable du FabLab de Polytech Lille. Nous tenons par ailleurs également à remercier chaleureusement Antoine, contributeur actif au Fablab de Polytech Lille, pour son partage d'expérience à propos de la création de son imprimante 3D RepRap, projet similaire au notre.
Définitions des objectifs
- Prendre un composant
- Stocker les composants à déposer sur la carte et identifier leur position
- Maintenir le composant par aspiration
- Repérer la position et l’orientation de la carte
- Déplacer le composant
- Le déplacer en translation selon les axes X, Y et Z
- L’orienter correctement sur les pastilles (rotation autour de Z)
- Déposer le composant
- S’assurer que l’outil d’aspiration n’endommage ni la carte, ni le composant lors de la dépose -> détecter le contact entre le composant et la carte
- Connaître la position désirée pour la dépose du composant
- Récupérer les fichiers provenant du logiciel de CAO et les transformer en déplacement de la machine
- Permettre à l’utilisateur d’avoir une interface visuelle (sur ordinateur) indiquant l’état des éléments de la machine et permettant leur calibrage
Liste des tâches
- Créer l’infrastructure mécanique de la machine (châssis)
- Fabrication du châssis
- Design des pièces mobiles et impression 3D de ces pièces au FabLab (chariot comportant l’outil d’aspiration et “guides tubes” assurant la transformation de la rotation des moteurs en mouvement de translation (glissières) sur des barres métalliques)
- Assembler l’outil d’aspiration au chariot
- Concevoir la commande d’aspiration par pompe
- Organiser la commande des moteurs du système pour l’asservissement en position de la machine
- Étude et prise en main des drivers pour les moteurs Pas à Pas
- Réalisation de l’interface commande-puissance
- Réaliser la conversion des données de position (relatives) de l’emplacement souhaités des composants en mouvements pour la machine
- Concevoir l’interface de récupération des données du fichier Gerber de l’utilisateur
- Caractérisation des différents repères (repère de la machine, repère de l’outil et repère de la carte) et établir le lien entres eux
- Détecter l’origine du repère de la carte au moyen d’une caméra fixe
Planning prévisionnel de répartition du travail
| Semaine 39 (21/09) | Brainstorming et réunions avec les encadrants de projet afin de définir les objectifs / Étude de faisabilité |
|---|---|
| Semaine 40 (28/09) | Brainstorming et réunions avec les encadrants de projet afin de définir les objectifs / Étude de faisabilité |
| Semaine 41 (05/10) | Dimensionnement des éléments du système et recherche du matériel à commander en tenant compte des contraintes de coût |
| Semaine 42 (12/10) | Achat du matériel pour le châssis de la machine (bois, tiges métalliques...) et pré-assemblage / Conception des pièces mécaniques à imprimer au FabLab |
| Semaine 43 (19/10) | Dans l'attente de la réception du matériel commandé : Conception des pièces mécaniques à imprimer au FabLab / Développement de l'application PC / Étude de l'asservissement en position |
| Semaine 44 (26/10) | Dans l'attente de la réception du matériel commandé : Conception des pièces mécaniques à imprimer au FabLab / Développement de l'application PC / Étude de l'asservissement en position et du repérage caméra |
| Semaine 45 (02/11) | Dans l'attente de la réception du matériel commandé : Conception des pièces mécaniques à imprimer au FabLab / Développement de l'application PC / Étude de la commande des moteurs et du repérage caméra |
| Semaine 46 (09/11) | Dans l'attente de la réception du matériel commandé : Fabrication du châssis - assemblage des pièces / Développement de l'application PC / Étude de l'asservissement en position et du repérage caméra |
| Semaine 47 (16/11) | Dans l'attente de la réception du matériel commandé : Impression 3D des pièces mécaniques / Développement de l'application PC / Étude de l'asservissement en position et du repérage caméra |
| Semaine 48 (23/11) | Dans l'attente de la réception du matériel commandé : Impression 3D des pièces mécaniques / Développement de l'application PC / Étude de l'asservissement en position et du repérage caméra |
| Semaine 49 (30/11) | Réception espérée du matériel : Montage de la maquette / Prise en main et calibrage des éléments / Tests |
| Semaine 50 (07/12) | Réception espérée du matériel : Montage de la maquette / Prise en main et calibrage des éléments / Tests |
| Semaine 51 (14/12) | Réception espérée du matériel : Montage de la maquette / Prise en main et calibrage des éléments / Tests |
| Semaine 52 (21/12) | Réception espérée du matériel : Montage de la maquette / Prise en main et calibrage des éléments / Tests |
| Semaine 53 (28/12) | Réception espérée du matériel : Montage de la maquette / Prise en main et calibrage des éléments / Tests |
| Semaine 01 (04/01) | |
| Semaine 02 (11/01) | |
| Semaine 03 (18/01) | |
| Semaine 04 (25/01) | |
| Semaine 05 (01/02) | |
| Semaine 06 (08/02) | |
| Semaine 07 (15/02) | |
| Semaine 08 (22/02) |
Retour sur les directives des encadrants
M. Flamen
Dans un premier temps, pour mieux définir les objectifs de notre projet, nous avons pris rendez vous avec M. Flamen. M. Flamen est le responsable du service électronique de PolytechLille. Il est le principal intéressé par notre projet car celui-ci (le projet) permettrait de disposer de la chaîne complète de fabrication de cartes électroniques CMS (composants montés en surface).
Cette rencontre avec M. Flamen nous a permis de déterminer certaines précisions, comme:
- La précision maximale demandé n'excédera pas 0,2 mm (précision de classe 5, qui est celle de la graveuse de carte du service EEI).
Liste de matériel
Matériel disponible
- Support
- 3 Tiges de 1 mètre [Reçu le 2015-10-12]
- 1 Tasseau de 2m70 (découpé pour fabriquer les supports des tiges) [Reçu le 2015-10-12]
- 1 Planche en bois pour effectuer le support du projet [Reçu le 2015-10-12]
- Motorisation
- 2 Moteurs Pas à Pas type NEMA 17 (pour axes X et Y) [1][Reçu le 2015-11-09]
- 1 Moteur Pas à Pas (pour rotation autour de Z) [2][Reçu le 2015-11-09]
- 1 Moteur Pas à Pas avec glissière intégrée (pour translation selon Z) [3][Reçu le 2015-11-09]
- 4 drivers pour moteur Pas à Pas bipolaire [4][Reçu le 2015-11-09]
- Outil d'aspiration
- Châssis mécanique
- 2 Courroies crantées plus grandes [Reçu le 2015-12-27]
Matériel manquant
- Rien pour le moment
Fabrication de l'infrastructure mécanique
Notre projet comprend une partie extrêmement importante de conception. Sur conseils de M. Astori, nous avons donc décidé d'utiliser une organisation plus particulière. Le principe de cette organisation est de créer des pièces (on parle ici uniquement de leur impression à l'imprimante 3D et de la phase de conception sous Catia) rapidement, avec une faible taux de remplissage (de l'ordre de 30%). Le but de cette méthode est de créer un nombre de pièces plus important, permettant plus facilement rectifications en fonction des remarques que nous tirons du montage.
La partie usinage
Nous avons commencé par acheter une support contreplaqué en bois. Sur ce support, nous avons disposé quatre pylônes reliés deux à deux par un axe métallique. Nous avons donc découpé à la scie à chantourner plusieurs linteaux de bois pour fabriquer les pylônes. Ensuite, nous avons usiné les pylônes à l'aide d'une perceuse à colonne pour leur permettre de recevoir l'axe métallique.
Ensuite, nous avons eu la surprise de recevoir des poulies non percées. Nous avons donc du les percer. Nous avons percé les deux premières à l'aide de la perceuse à colonne. Le désavantage de cet outil est son imprécision sur la largeur de perçage. De plus, il n'était pas possible d'y ajouter un mécanisme permettant son maintien au moteur. Par conséquent, nous avons eu la chance d'être aidé par l'atelier mécanique. Ainsi, nous avons usiné les deux dernières poulies à l'aide d'un tour conventionnel (sous la supervision du responsable de l'atelier mécanique). Nous avons ensuite, toujours avec l'aide de M.Yoan Dhont, percé les deux poulies selon un axe perpendiculaire au précédent et créé un filetage pour permettre l'insertion d'une vis sans tête pour assurer la fixation au moteur.
Pour des raisons pratiques et esthétiques, nous avons demandé à la menuiserie de Polytech Lille de corriger nos pylônes pour assurer leur perpendicularité. Cette correction a été effectuée par M. David [TODO] et M. JP [TODO] à l'aide d'une scie à bande. Par la suite, nous avons marqué le support pour faciliter le perçage et l'ajustement des pylônes. Une fois les marquages, nous avons percé le support et les pylônes pour assurer une bonne fixation.
La partie impression
Nous avons commencé par créé un chariot permettant le déplacement selon l'axe X, et permettant d'embarquer le moteur pour le déplacement selon Y. Nous l'avons créé à l'aide du logiciel Catia. Les cotes imposés sur le schéma sont celles fournies par la documentation et par mesure des axes métalliques au pieds à coulisse.
Après impression, nous nous sommes aperçu que la documentation comprenait une erreur importante sur la taille des moteurs, nous obligeant à réimprimer une deuxième pièce. Nous avons profiter de la deuxième impression pour réduire la surface de contexte entre l'axe X de la pièce et l'axe métallique X.
La deuxième pièce est très identique à la première à la différence près qu'elle n'embarque pas de moteur. Elle embarque uniquement une poulie permettant le passage de la courroie de transport en Y. Cette version, bien que fonctionnelle, n'a pas eu (pour le moment) l'amélioration apportée par la deuxième version de la pièce 1 (c'est à dire la réduction de surface de contact).
Les deux dernières pièces sont des pièces de support pour permettre au moteur de l'axe X et à la poulie de l'axe X de se maintenir sur leur pylône respectif. Le support de poulie n'a tenu que deux jours avant de rendre l'âme. Nous avons donc remplacé de façon temporaire son axe par une longue vis à bois. Le support de moteur n'a, lui, pas cassé, mais nécessite d'être imprimer une deuxième fois car la documentation du moteur était incorrecte (encore une fois).
Quelques jours avant la pré soutenance, les pièces semblent fonctionnelles. Une amélioration peut être apportée dans un second temps en modifiant les guide d'axe par des poulies (imprimées à l'imprimante 3D) permettant de suivre plus fidèlement l'axe métallique. Ce système sera développé durant les semaines suivants la pré soutenance.
Motorisation et asservissement en position
Besoins et choix des moteurs
Nous avons besoin de déplacer notre chariot comportant l'outil d'aspiration qui manipule les composants selon les 3 axes de l'espace X, Y et Z. Afin d'assurer les translations dans le plan (X,Y), nous nous sommes orienté vers un système moteur-poulie-courroie sur chacun de ces 2 axes. Nous avons besoin d'une précision en position de l'ordre de 0,2mm et n'avons pas un besoin en couple important, ni d'un asservissement en vitesse spécifique.
Nous avons donc choisi d'utiliser des moteurs Pas à Pas, qui offrent les avantages d'être précis en terme de position angulaire, de pouvoir adapter cette précision en les commandant en micro-pas et surtout de pouvoir réaliser l'asservissement en position sans capteurs. En effet, nous nous baserons sur le comptage du nombre de pas que l'on a fait effectuer au moteur, en supposant qu'aucun pas n'est sauté durant le déplacement. En effet, dans notre application la charge a entrainer est suffisamment faible et le déplacement se fera a une vitesse suffisamment basse afin d'assurer cette hypothèse.
Dans une seconde version, pour être sûr du positionnement et pour palier aux imprécisions (type jeux sur la maquette...) sur la position initiale, la position de la poulie et son diamètre, nous mettrons en place un système d'ajustement via une caméra, où l'utilisateur viendra valider le placement du composant avant dépose sur la carte.
Le déplacement de position est alors déduit ainsi : 
avec 
le pas angulaire de nos moteurs en radian (ici, 1,8°=0,031415 rad) ,
le facteur de micro-pas choisi (typiquement 1/2, 1/4, voire 1/8), 
le rayon du moyen de la poulie crantée en mm (ici 7,15mm) et 
le nombre de pas demandé (dans un sens ou dans un autre).
Pour enfin connaitre la position absolue, il s'agit de connaitre la position initiale du chariot. Ceci sera réalisé avec des capteurs "fin de course", type contacteurs à lamelles.
Commande des moteurs Pas à Pas
Le principal inconvénient des moteurs Pas à Pas réside dans la commande de ceux-ci. En effet, un moteur Pas à Pas est un moteur particulier sans balai et alimenté par une alimentation continue. Il comporte plusieurs bobines permettant de créer un champ magnétique à l'intérieur et ainsi d'orienter des aimants fixés au rotor dans la direction du champ magnétique crée, ce qui provoque la rotation de l'arbre. On utilise le terme Pas à Pas car le champ magnétique crée à l'intérieur se fait par incréments. Ainsi pour faire tourner l'arbre entièrement, il faut effectuer l'alimentation des bobines pour une position 1, puis position 2, et ainsi de suite, selon la géométrie et la technologie du moteur utilisées.
Ainsi, le contrôle de celui ci s'effectue par une séquence d'alimentation spécifique de ses différentes phases. Dans notre cas, nous avons choisi des moteurs bipolaires (de type Hybride, c'est à dire combinant les avantages des technologies "à aimant permanent" et à "réluctance variable"). Le sens de rotation des ces moteurs dépend de l'ordre d'alimentation des 2 bobines, ainsi que du sens du courant.
Ce pilotage peut s'effectuer au moyen d'une électronique de puissance type pont en H, sur laquelle on pilote les séquences de commutation des différentes cellules de commutation (transistor + diode en sens inverse en parallèle). Cependant une telle structure est compliquée à mettre en place au niveau des séquences, n'intègre pas directement de limitation active du courant délivré dans la bobine et surtout n'intègre pas directement de variation de courant afin de contrôler le moteur en micro-pas.
Présentant des prix très faibles (environ 5€) pour l'économie de temps et la simplicité d'utilisation qu'ils représentent, nous avons donc cherché des solutions de drivers adaptés à nos moteurs. Basé sur le circuit A4988 d'Allegro, nous nous sommes tourné vers ce driver pour moteur bipolaire (Pololu A4988 Stepper Motor Driver Carrier). Son principe est simple : il intègre directement cette structure de pont en H et les séquences d'alimentation. Il permet ainsi de faire effectuer au moteur un pas en envoyant une impulsion (front montant) sur sa pin STEP, dans le sens défini par l'état (haut ou bas) de sa pin DIR.
Ce driver réalise également l'interface commande-puissance, il comporte une alimentation séparée pour le circuit logique (5V) et l'alimentation de puissance des moteurs (ici 12V). Il est très important pour éviter la surchauffe et l'endommagement des moteurs de contrôler le courant envoyé dans ses bobines. Nous limitons ainsi activement ce courant grâce au driver au moyen d'un potentiomètre à régler sur ce dernier. Nous avons réglé cette valeur par rapport aux courants nominaux par phase de nos moteurs.
L'avantage majeur de ce driver est qu'il comporte une solution de fonctionnement en micro-pas directement. Par l'état de ses pins MS1, MS2 et MS3, il nous permet de piloter du pas complet, au 1/16 de pas (maximum). Nous ne piloterons pas jusqu'au 1/16 de pas pour des soucis de stabilité du couple mécanique et pour éviter de sauter des pas, 1/4 voire 1/8 de pas devrait être suffisant. Le choix du micropas maximum sera à déterminer avec les tests sur la machine.
Ainsi, nous pilotons toutes ces différentes entrées par le biais d'un Arduino Mega. Plus tard, cet Arduino Mega servira d'interface entre la consigne de position envoyée depuis l'application PC et les moteurs.
[[Fichier:|200px|thumb|right|Photo de la partie commande des moteurs]]
Création de l'outil de manipulation par aspiration
L'outil qui viendra attraper et déposer les composants sera composé d'une aiguille fine qui les maintiendra par aspiration. Le système sera donc composé d'une pompe à vide, type pompe d'aquariophilie, peu couteuse, car l'aspiration nécessaire pour maintenir un composant est vraiment très faible. Ce genre de pompe se commande en tout ou rien au moyen d'un interrupteur manuel. Afin de ne pas alterner cycles d'allumage de la pompe pour éviter de l'endommager et surtout d'attendre le temps d'établissement du débit à chaque fois, lors des phases aspiration-dépose, nous utiliserons un distributeur pneumatique qui viendra envoyer ou non la dépression dans le tuyau d'air.
Une partie majeure du travail va consister en la conception de la pièce mécanique, le chariot, qui intégrera les moteurs pour effectuer la translation et la rotation autour de Z, un capteur piézoélectrique qui permettra la détection du contact entre le composant et la carte et qui intégrera un espace prévu à cet effet pour maintenir le tuyau et l'aiguille. Ce chariot sera adaptable au reste du châssis et comportera une partie qui le fixe à la courroie.
Niveau matériel pour cette partie, nous avons pour le moment réuni le distributeur, les tuyaux et l'aiguille. Nous devrions recevoir la pompe sous peu de temps.
Conception du logiciel
Définition du cadre
Un des buts de ce projet est de concevoir une application permettant de contrôler les différents éléments du projet. Pour cela nous, l'application doit être capable de lire des fichiers standards de création de carte électronique (aussi appelés fichiers Gerber). De plus, nous souhaitions que l'application puisse être utilisé sur n'importe quelle plateforme. Pour cela, nous avons choisi de la développer sous Qt. L’environnement de travail Qt nous permet d'utiliser des objets permettant l'accès à n'importe quel type de matériel sans se soucier de la plateforme de destination. Pour la communication avec les éléments de commande (comme les moteurs) nous avons choisi de n'envoyer des ordres qu'à travers l'Arduino Mega.
La communication entre le logiciel et l'Arduino Mega
Création d'un système sûr pour Arduino Mega
L'application de bureau que nous avons créé va, comme expliqué précédemment, communiqué avec un Arduino Mega. Cet Arduino s'occupera de la commande de la partie du puissance du reste du système. Ces fonctions sont:
- Commander des moteurs sur les axes X, Y et Z
- Commander de la rotation selon Z
- Contrôler de la pompe
- Définir les paramètres avancés des moteurs (vitesse, précision des micropas)
- S'assurer de ne pas commander un ordre endommageant la machine
Le protocole de communication
Pour permettre de réaliser ces fonctions, l'application communique à travers le port série avec l'Arduino Mega. Le protocole utilisé est rendant le plus compact possible pour limiter le nombre de communications.
L'Arduino Mega ne fonctionne que par tâches (comme décris sur le schéma à droite). La seule possibilité pour l'Arduino de ne pas être dans cette exécution de tâches est d'être interrompu par un contact à lamelle souple (que nous considérons comme prioritaire). Dans ce cas, l'Arduino reste bloqué dans la fonction appelé par l'interruption jusqu'à temps que l'utilisateur valide manuellement la déverrouillage (ce qui permet d'éviter que le système ne puisse s’abîmer).
| Bits | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0 |
|---|---|---|---|---|---|---|---|---|
| Data | Paramètre | Fonction appelée | ||||||
Liste des fonctions d'écriture
| Fonction appelée | Nom de la fonction | Paramètre 1 | Paramètre 2 | Description fonction | ||||
|---|---|---|---|---|---|---|---|---|
| b3 | b2 | b1 | b0 | Hex | ||||
| 0 | 0 | 0 | 0 | 0x00 | setDest | selectedMotor[2bits] | destination[16bits] | Donne la consigne de position en seizième de pas par rapport à l'origine |
| 0 | 0 | 0 | 1 | 0x01 | setMS | selectedMotor[2bits] | microStep[3bits] | Donne la consigne du nombre de micropas par tour pour un moteur |
| 0 | 0 | 1 | 0 | 0x02 | setPump | onOff[1bit] | ∅ | Donne la consigne d'allumage ou d'extinction de la pompe à vide |
| 0 | 0 | 1 | 1 | 0x03 | setADC | adcLevel[10bits] | ∅ | Donne la consigne d'allumage de la valeur maximale lisible par l'ADC |
| 0 | 1 | 0 | 0 | 0x04 | setRelease | lockToRelease[3bits] | ∅ | Donne la consigne de déverrouillage d'un nœud précédemment verrouillé |
| Fonction appelée | Trame 1 | Trame 2 | Trame 3 | |||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| b7 | b6 | b5 | b4 | b7 | b6 | b5 | b4 | b3 | b2 | b1 | b0 | b7 | b6 | b5 | b4 | b3 | b2 | b1 | b0 | |
| setDest | selectedMotor[1:0] | ∅ | destination[15:8] | destination[7:0] | ||||||||||||||||
| setMS | selectedMotor[1:0] | ∅ | microStep[2:0] | ∅ | ∅ | |||||||||||||||
| setPump | onOff | ∅ | ∅ | |||||||||||||||||
| setADC | adcLevel[9:8] | ∅ | adcLevel[7:0] | ∅ | ||||||||||||||||
| setRelease | ∅ | lockToRelease[2:0] | ∅ | |||||||||||||||||
Liste des fonctions de lecture
| Fonction appelée | Nom de la fonction | Paramètre 1 | Description fonction | ||||
|---|---|---|---|---|---|---|---|
| b3 | b2 | b1 | b0 | Hex | |||
| 1 | 0 | 0 | 0 | 0x08 | getDest | selectedMotor[2bits] | Retourne la position d'un moteur donné en seizième de pas par rapport à l'origine |
| 1 | 0 | 0 | 1 | 0x09 | getMS | ∅ | Retourne la consigne du nombre de micropas par tour pour tous les moteurs |
| 1 | 0 | 1 | 0 | 0x0A | getPump | ∅ | Retourne la consigne d'allumage actuelle de la pompe à vide |
| 1 | 0 | 1 | 1 | 0x0B | getADC | ∅ | Retourne la consigne d'allumage de la valeur maximale lisible par l'ADC |
| 1 | 1 | 0 | 0 | 0x0C | getRelease | ∅ | Retourne l'état de verrouillage des nœuds |
| Fonction appelée | Trame 1 | |||
|---|---|---|---|---|
| b7 | b6 | b5 | b4 | |
| getRelease | ∅ | selectedMotor[1:0] | ||
