Planche de Galton
Planche de Galton
Par François Beugin et Teddy Turquet.
Contexte
Dans le cadre de notre projet RSO Ludinfo nous avons décidé de construire une planche de galton. Qu’est-ce que Ludinfo ? Ludinfo permet de faire découvrir à des collégiens de découvrir le monde de l’informatique et des mathématiques de manière ludique et sans ordinateur. Le but de la planche de Galton était d’expliquer un théorème fondamental en statistique : Le théorème centrale limite.
Principe
Souvent utilisé dans les jeux de foire, la planche de Galton met en scène une bille qui est confronté entre aller à droite ou à gauche. Et ceux, à de multiples reprises. Pour finir laisser tomber les billes dans différents puits dépendant du chemin pris par la bille. Ainsi, on se retrouve avec une distribution de bille dans les différents puits. Le théorème central limite explique le résultat : la distribution est une courbe de gauss.
On peut expliquer le phénomène assez facilement car la destination de la bille suit l’addition de plusieurs lois binomiales avec p=1/2 car la bille a autant de chance d’aller à droite ou à gauche. En appliquant le théorème centrale limite sur cette expérience on trouve la présence d’une distribution normale.
La construction
Préparation
La préparation de la planche de Galton est une étape très importante. En effet, La bille est soumise à des phénomènes aléatoires, il faut alors une préparation minutieuse pour laisser le moins d’imprécision possible et garder l’équiprobabilité.
La préparation s’est déroulé en deux étapes :
- Etablissement des mesures
- Choix des matériaux
Nous avons décidé d’utiliser des billes d’airsoft comme bille car elles conviennent parfaitement à notre problème : Accessible facilement et de bonne taille pour répéter de nombreuses fois l’expérience.
Notre première mesure était donc la taille des billes : 6mm de diamètre.
Nous avons donc acheté des plaques de MDF de 6mm.
Les mesures restantes ont été choisi de manière un peu arbritraire. Nous avons pris 1cm pour le largueur des conduits et 2cm pour la taille des hexagones.
Découpage
Pour le découpage nous avons utilisé : La découpeuse laser pour avoir la meilleure précision possible et a scie à chantourner pour les parties moins importantes.
Nous avons ainsi dessiné sur Inkscape des hexagones. (Un lien du fichier .dxf est disponible)
Grâce à ce dessin vectoriel nous avons pu utiliser la découpeuse laser.
Nous avons, ensuite, découpé les autres parties avec la scie à chantourner.
Pour les puits nous avons découpé des bandes et pour les pieds des triangles rectangles
Collage
Nous avons ensuite collé les hexagones un par un avec de la colle à bois. En respectant, le schéma suivant :
Après ça nous avons collé les gouttières avec de la colle à bois et les pieds avec du silicone.
Résultats
Bilan
Le résultat est très intéressant car nous voyons bien la courbe de gauss se dessiner, malgré un petit décalage, due aux imperfections du collage.
Chems Bihan
Dans l’école IMT-Atlantique, le centre vie est le cœur de l’établissement et rassemble élèves, professeurs et personnel de l’école. C’est à la fois un lieu de travail, de détente, de rencontre et un lieu d’échange. Une grande ouverture vitrée longe ce lieu pour laisser passer la lumière du jour. Le soir, plus d’une centaine de lampes sont allumées pour illuminer cet espace. Dans le cadre d’un partenariat avec l’Ecole Européenne Supérieure d’Art de Bretagne (EESAB), nous avons donc décidé de créer un luminaire qui pourrait s’adapter aux diverses activités du centre vie.
Ce prototype est le fruit de la collaboration entre deux étudiants de Telecom Bretagne: EL AYACHI Mehdi et BADDAJE Dina, tous les deux étudiant en première année cycle ingénieur généraliste, et deux étudiante de l’EESAB: FLEURY Pauline et MEVEL Gaëlle, toutes les deux en troisieme année en cycle design, sous l’encadrement de professeurs de chaque école.
Le matériel électronique utilisé est:
– Une carte Arduino
– Une baterie portable et rechargeable via port USB
– Un disque de 6 LED RVB + un disque de 17 LED RVB
– Un émetteur/récepteur bluetooth
– 3 plaques de bois de dimensions 5mm x 30cm x 45cm
– Un téléphone muni d’un système Android
Chems Bihan est un petit objet de 20 centimètres de diamètre destiné aux tables mises à dispositions dans cet espace. Il permet une vingtaine de modes d’éclairage différents, chacun adapté à une exploitation précise du centre vie (Travail de jour, travail de nuit, discutions entre amis, mode veille qui économise l’énergie…). Ces modes ont été téléversés sur une carte Arduino qui contrôle 23 LED RVB neopixels disposées circulairement au centre du luminaire. Les utilisateurs pourront définir le mode de fonctionnement de ce luminaire à travers une application Android connectée via Bluetooth à la carte Arduino. L’alimentation du prototype est assurée par une batterie rechargeable par lien USB qui permet une autonomie de 10 heures.
L’application a été conçu avec le logiciel IMT Appinventor, un logiciel gratuit et disponible en ligne qui facilite la réalisation d’application Android et même la modification de son design. Grâce à cette application l’utilisateur peut choisir un mode de fonctionnement de la lampe, un caractère ASCII correspondant à ce mode est alors envoyé via la liaison bluetooth a la carte qui lance le mode en question.
Le luminaire a été réalisé en bois découpé au laser, des lames ont été placées autour des LED et intercalées sur deux cercles de diamètre différent pour permettre un éclairage optimal, le plus petit support étant mobile afin de permettre à l’utilisateur de contrôler la largeur du faisceau lumineux. Le principe de son fonctionnement est proche d’un diaphragme. De plus il comprend un pardessus en verre semi-opaque qui permet de diffuser la lumière provenant des LED RVB.
Docile, une lampe interactive
Projet inter semestre 2017 Fablab
Membres du groupe : Hakim Belanouane, Teddy Turquet, Jennifer Abguillerm et Loïck Bouier.
Collaboration entre étudiants ingénieurs de l’IMT Atlantique et étudiants designers de l’EESAB du 19 au 27 janvier.
Etude du problème
Sujet
Le centre vie de l’IMT Atlantique est un lieu où se rencontre étudiants, professeurs, associations, et entreprises. Le soir, ce site est occupé par des étudiants qui désirent travailler ou tout simplement se réunir. Mais nous constatons que le centre vie manque de lumière à partir d’une certaine heure. Notre rôle est donc de trouver une solution au manque de luminosité dans une démarche d’écoconception pour répondre à ce besoin.
Notre solution
L’idée clef de notre groupe est de faire une lampe interactive et portable.
L’utilisateur pourra donc transporter sa lampe, changer sa couleur et sa luminosité avec un mouvement simple, rapide et intuitif. Sa forme doit être maniable pour être positionné selon les goûts de l’utilisateur. Toutes ces options seront conçues afin que l’utilisateur puisse personnaliser au maximum l’éclairage de son espace de travail.
Analyse Fonctionnelle
| FP1 | Eclairer suffisamment |
| FP2 | Etre transportable et avoir une autonomie supérieure à 2h |
| FC1 | Le réglage de l’intensité et de la couleur doit être interactif |
| FC2 | La lampe peut se positionner de multiple façon |
| FC3 | Ecologique et Econome |
FP : Fonction principal
FC : Fonction complémentaire
Première réflexion
1) Hardware
- Interactivité
Nous avons décidé de ne pas utiliser un écran tactile intégré à la lampe car le coût est bien trop élevé. Nous avons donc choisis d’utiliser des capteurs ultrasons pour avoir un retour d’information sur la décision de l’utilisateur. La lampe se contrôle grâce à la distance entre la lampe et le premier obstacle que l’onde rencontre. Le passage d’une main peut donc être détecté.
- Système embarqué
Pour être transportable nous avons besoin d’intégrer tout le système électronique dans la lampe,
Pour l’alimentation on doit calculer le nombre de piles en fonction du nombre de Del, donc on doit connaitre la consommation par heure d’une Del.
Une carte Arduino nano suffira pour notre utilisation, son premier avantage est sa taille réduite comparé à une carte Arduino Uno.
2) Software
La programmation se fait donc en langage C via le logiciel Arduino. Nous avons séparé les tâches : Commandes des Del et détection des différents mouvements de main
Pour plus de simplicité nous avons créés des bibliothèques que vous retrouverez dans la dernière partie.
3) Design
Nous avons une contrainte sur la taille de l’objet, elle doit être de taille moyenne voir petite pour être transportable. Tous les composants électroniques doivent être cachés pour éviter de les abîmer en transportant l’objet.
La forme qui a été retenu en premier lieu est une lampe dépliable en forme de U fait de bois.
Et après réflexion, pour diminuer l’épaisseur de l’objet on s’est fixé un V comme forme finale.
Mise au point
Récapitulatif de notre solution
| FP1 | Nombre importants de Del et une surface en plexi glace pour diffuser la lumière |
| FP2 | Mise en place d’une alimentation adaptée au nombre de DEL |
| FC1 | Réglable par le passage de la main au-dessus de la lampe |
| FC2 | Une forme en V avec un pivot pour s’ouvrir et se refermer |
| FC3 | Des composants électroniques low cost et des piles rechargeables |
Description du matériel utilisé
Microcontrôleur : Arduino nano
Capteur ultrason : Modèle HC-SR04
DEL : Bande de led RGB
Réalisation du prototype
Alimentation
Une Del consomme 60mA Maximum
On a décidé de mettre 3 bandes de 10 Dels donc 30 Dels
Un banc de 4 piles AAA fait 1000mAh
On a décidé de mettre 2 bancs de piles en parallèle pour avoir 2000mAh
A la puissance maximum les Dels peuvent être alimentées pendant une heure mais on diminue la puissance max des led pour arriver à 2h-3h.
Schéma électrique de l’alimentation
Le Data permet de commander la couleur des Dels RGB, elle se branche donc sur un pin qui est doté de l’option PWM (Power width modulation)
Dessin technique
Vue du dessus
Vue de droite
Ces dessins nous ont permit de couper précisément les planches de bois pour créer des emplacements pour chaque composant. Chaque planche a une épaisseur de 5 mm
Plan découpe laser : planche-du-prototipe-fini
Programme informatique
On a décidé de mettre 3 commandes sur la lampe :
Passage à la couleur suivante : Il faut faire passer sa main de droite à gauche au-dessus des capteurs
Retour à la couleur précédente : Il faut faire passer sa main de gauche à droite au-dessus des capteurs
Et réglage d’intensité : il faut rester 2 secondes à une distance inférieur à 5 cm au-dessus des capteurs pour actionner se mode ensuite l’intensité variera en fonction de la distance entre la main et les capteurs. Pour fixer l’intensité lumineuse choisie il faut immobiliser sa main 2 secondes.
Les programmes sont disponible ici : lampws
Evaluation du coût des composants
Arduino nano : 4.5€
Bande de DEL : 10€
2 Capteurs : 14€
Interrupteur a contact : 2€
Piles : 10€
Prix total pour la partie électronique : 40,5€
Amélioration envisageable
La possibilité de programmer plus de mouvements pour commander la lampe d’une différente façon. On pourra aussi sortir de la structure la partie Mini-B USB Jack de l’arduino nano pour pouvoir reprogrammer l’arduino et que cette lampe devienne un outil pédagogique de programmation en C.
Contact
Notre projet s’adresse aux personnes qui passent du temps au centre-vie, notamment ceux qui voudraient y faire une pause pour se détendre.
Nous souhaitons, à travers ce projet, transformer et animer un espace oublié à l’intérieur du lieu de vie : les alcôves.
L’idée est d’utiliser la lumière pour susciter la curiosité, attirer les élèves et professeurs dans un espace où l’objet rentre en contact avec eux.
Information sur le placage bois et le capacitif de notre lampe
L’Arduino Promini : ou comment conserver ses projets pour pas cher…
Introduction
Au coeur de beaucoup de projets, l’Arduino Uno est une pièce angulaire de l’asservissement de structure. Face à la taille et au coût d’une telle carte, bon nombre de projets se retrouvent désossés à la fin d’une exposition afin de récupérer cet élément. Pour éviter ces moments de démantèlement nous vous conseillons d’utiliser l’Arduino Pro Mini ! Cette carte électronique dotée d’une Atmega328 (même puce que sur une Arduino Uno) a l’avantage de ne coûter que 2$. Forcément à ce prix, vous l’imaginerez il y a quelques désavantages, notamment l’absence de port USB. Dans ce tutoriel, nous vous proposons la technique par excellence pour programmer ce type de carte à travers l’USB de votre Arduino Uno. Oui, OUI ! vous allez enfin pouvoir recycler votre ancienne carte Uno à des fins économiques 😀
La préparation :
Afin de programmer notre Pro mini nous allons utiliser l’interface USB de la carte Uno. Pour ce faire, avant de réaliser les câblages vous allez devoir retirer la puce Atmega328. Cette opération a pour but d’isoler l’interface USB de la carte arduino.
Le câblage
Une fois isolé, la carte arduino Uno va enfin pouvoir nous servir de module TTL. voici le câblage :
L’Upload
Suite à cette phase de câblage, il ne vous reste plus qu’à choisir le type de votre pro Mini dans :
« outils >> type de carte >> Arduino Pro Mini »
Puis suivant votre type de processeur (328 ou 168) allez sous la rubrique « processeur » dans :
« outils >> type de carte >> processeur »
Nota :
Si vous désirez faire un test avec un blink, notez que la diode native est positionnée sur la pin 9 et non sur la 13 comme sur la Uno.
Le code :
Le code se partage en deux grands axes : le contrôle du dispositif capacitif et la partie animation des lumières.
Pour ce qui est de la gestion des entrées capacitives, nous nous sommes basé sur le code contenus dans le blog suivant :
https://skyduino.wordpress.com/2012/06/02/arduino-faire-une-touche-tactile-avec-une-simple-resistance/ grâce a un principe de lecture/écriture rapide, il est possible de lire la décharge propre à une broche.
Le code concernant l’allumage des LED a de prime abord été développé en suivant le paradigme objet, solution se révélant peu appropriée au peu de mémoire dont dispose les Arduino.
Par la suite, une solution plus modulaire a été adoptée. Le cœur du programme final se sépare en 2 classes :
– La classe Strip, contenant toutes les méthodes permettant de manipuler les LED,
– La classe Queue permettant aux LED d’être animées.
La première se charge de stocker l’état de chaque LED et de modifier les couleurs d’une LED en particulier, d’un étage, ou de tout le ruban.
La seconde, chargée de l’animation, se charge de stocker les états initiaux et finaux de chaque LED, ainsi que le temps de transition, permettant de rendre des transitions de couleur fluides.
Le code a été pensé pour qu’il soit simple d’utilisation et très intuitif. Une simple instruction « floor(1)->setColor(255, 0, 0); » permet d’illuminer l’étage 1 en rouge.
« queue->store({ 0, 100, FLOOR, COLOR, 1, 255, 0, 0, 0, 255, 0 }, strip); » permet de faire varier en 100 étapes la couleur de l’étage 1 de rouge à vert.
0 : convention
100 : nombre d’étapes
FLOOR : on colore un étage
COLOR : on définit une couleur (pas un dégradé)
1 : numéro de l’étage
255, 0, 0 : rouge
0, 255, 0 : vert
Hijo de la Luz
Amelie Laurent
Delphine Le Boulaire
Elkin Aguas
Juana Cordova
« Hijo de la Luz »
Le Centre de Vie peut être considéré comme le coeur de l’IMT où l’ensemble des flux convergent. Cet espace est habité par différents composants tels que les usagers, le mobilier, et les plantes.
En effet, ce lieu de vie accueille à la fois les étudiants, les professeurs mais également le personnel, les visiteurs.
Tout d’abord, nous sommes partis du principe que dans un centre de vie il y a la vie, lumière et mouvement. Donc plus il y a de vie, plus il y a de mouvement. De ce fait, nous souhaitons réaliser un petit dispositif nomade, habitant et témoin de l’activité au sein de cet espace.
Par des capteurs, ce dispositif rendrait compte des mouvements humains; plus il y a de mouvement, plus il y a de lumière et donc, plus il y a de vie. Nous y intégrons également un capteur d’intensité lumineuse afin que le dispositif s’adapte aux variations de la lumière naturelle pénétrant dans le lieu.
D’autre part, au lieu de dissimuler le système électrique, nous revendiquons un objet brut. La structure filaire de cet objet-habitant donne à voir la totalité des éléments constitutifs, et valorise son esthétique électronique interne tel que l’Arduino et les câbles. En tant qu’objet vivant, son aspect poétique est renforcé par cette esthétique. En somme, nous souhaitons révéler ce qui donne vie à cet objet. Au-delà de l’aspect esthétique et poétique, l’accumulation de câbles permettrait de diminuer l’impact visuel des LED.
Matériel Electronique :
– 1 Capteur de luminosité (LDR)
– 4 Capteurs de proximité
– Capteur de son
– 1 Résistance 1kΩ
-4 Neo-LEDs
– Arduino avec des câbles et connecteurs USB
– Câbles
Fonctionnement :
Pour la partie électronique, nous utilisons trois capteurs.
Le premier est un capteur de luminosité (LDR Light Dependant Resistor) dont la résistance change en fonction de la lumière qu’il y a dans le lieu. Selon ce changement les LEDs reçoivent ou non de la puissance.
Le second est un capteur de proximité dont les LEDs changent de couleur selon la présence des personnes au Centre de Vie.
Le troisième est un capteur sonore. Lorsqu’il n’y a pas de bruit ou qu’il est faible, les LEDs sont bleus. Puis, elles deviennent rouges avec l’amplification du son.
Nous réalisons deux objets. Les capteurs de luminosité et de proximité sont placés dans la première structure lumineuse, tandis que le capteur de son est dans la seconde.
Video:
Circuits:
(source prope)
Projet développement :Braille pour grimpeur
BEDETTI Corto
BLANCHARD Elisa
MASSOT Guillemette
Le but de notre projet développement est de faciliter la pratique de l’escalade pour les personnes déficientes visuelles. Afin de leur permettre d’avoir une première appréhension des prises pour une voie donnée, nous avons réalisé une maquette 3D représentant leur position et leurs formes.
Dans un premier temps, nous nous sommes intéressés aux moyens à mettre en œuvre pour acquérir les données sur les prises, c’est-à-dire leur position, leur couleur ainsi que leur forme. Nous avons réalisé des traitements sur l’image 2D grâce à un programme Python, afin de ne garder que les prises d’une même couleur.
-
- Mur d’escalade de Télécom Bretagne
-
- Image obtenue après traitement de la voir bleue
Pour que ce traitement soit plus précis, en évitant par exemple les erreurs dues aux traces laissées par d’anciennes prises ; nous avons rajouté une correction manuelle, pour ajouter ou supprimer des prises. Nous avons ainsi obtenu une image contenant uniquement les prises d’une même couleur, c’est-à-dire les prises formant une voie d’escalade.
Image obtenue après traitement de la voir bleue
Suppression manuelle d’une prise parasite
La voie ainsi reconstruite, nous avons converti l’image en un fichier compatible avec l’imprimante 3D, et avons distingué les prises du fond en faisant varier l’épaisseur d’impression.
Maquette 3D de la voie bleue
Enfin nous avons réalisé une interface permettant de reproduire automatiquement le même traitement en se basant sur une photo. Une fois la photo chargée dans l’interface, l’utilisateur sélectionne une prise. L’interface distingue ensuite automatiquement toutes les prises de cette couleur pour reconstituer la voie. L’interface est accompagnée d’une fiche d’explication donnant quelques conseils concernant l’acquisition des données, afin d’avoir un traitement optimal.
L’interface nous permet de récupérer les données RGB (triplet de couleur) d’un point sélectionné sur la prise. On définit ensuite un seuil de tolérance, ainsi on ne conserve que les pixels dont les données RGB appartiennent à l’intervalle [valeur initiale – seuil; valeur initiale + seuil]. On ajoute une bande sur l’image pour que les personnes déficientes visuelles puissent repérer le haut de la maquette.
L’interface manuelle permet d’ajouter ou de supprimer des prises. Le programme rajoute un carré respectivement de la couleur de la voie ou noir à l’endroit où l’on clique.
Lien pour les codes : https://github.com/GuillemetteMassot/Interface
Co-Opération
Description
Dans le cadre de l’intersemestre Fablab et Design avec L’EESAB, nous avions réaliser un prototype en groupe ( double binôme, l’un de Telecom Bretagne, l’autre de l’EESAB). Nous avons décidé de poursuivre ce projet pour le projet développement. Ce projet a pour thème le numérique à l’école.
Ce projet se divise en deux partie : La réalisation d’un jeu éducatif Co-Opération, et le développement d’ateliers éducatifs pour des enfants du cycle 3 ayant pour but de les initier à l’informatique et à l’électronique.
I-Co-Opération
But du Projet
Ce projet est une activité ludique et éducative pour apprendre les tables de multiplication. C’est un jeu qui se joue à deux, en coopération. Il se présente sous la forme de deux estrades recouvertes d’un tapis,ces dalles sont découpées en 9 cases et forment un pavé numérique d’un mètre carré, et d’une stèle comportant en son sein une carte arduino ainsi que deux afficheurs composées de LEDs adressables. Le but du jeu est de retrouver les facteurs d’un produit donné. En effet, l’écran affiche un nombre correspondant à un produit de deux chiffres, et les élèves doivent se concerter pour retrouver via leur tapis le nombre affiché (par exemple: 56 s’affiche à l’écran et l’un des enfants doit se mettre sur le 8, l’autre sur le 7). Pour cela, ils doivent se tenir debout sur les cases du pavé numériques adéquates.
Ces estrades sont sensibles à la pression appliquée sur les cases numérotées, permettant ainsi la détection d’une réponse de l’enfant. Une fois les deux enfants sur leur case, un délai d’une seconde s’écoule avant que la réponse ne soit validée ou infirmée.
Du point de vue esthétique développé par les étudiantes de l’EESAB, la recherche tourne autour de l’aspect graphique du tapis et de la stèle. Les formes vives et attractives sont importantes pour l’enfant. Aussi il est décidé que le mouvement de l’enfant est primordial dans le jeu. Ainsi il devient acteur de son apprentissage.
Solutions Techniques
Affichage
Dans notre système nous devons afficher le produit que les élèves doivent trouver, le score et indiquer si une réponse est bonne ou mauvaise. Pour cela nous avons utiliser des Néopixels. Ces LEDs adressables sont une bonne solution car on peut les mettre en série et les contrôler une à une ce qui permet d’utiliser très peu de pins de l’Arduino et de facilement afficher des chiffres. Le constructeur mettant à disposition une bibliothèque pour pouvoir facilement les contrôler. L’autre avantage de ces LEDs est qu’elles sont RGB, dans le cadre de notre projet cela nous permet de valider ou non la réponse d’un élève en changeant la couleur du produit. Il passera au orange pour une mauvaise réponse et au bleu pour une bonne réponse.
Les interrupteurs
Le second problème que nous avons rencontré est celui de gérer les 18 interrupteurs que sont les plaques numérotées sans pour autant surcharger l’Arduino, qui n’a pas assez d’entrées. Nous avons penser résoudre ce problème en utilisant dans un premier temps des registres à décalage. Ceux ci permettent de prendre des entrées en parallèles pour en faire une seule sortie en série. Ce dispositif n’utilise que 4 pins quelque soit le nombre d’entrées en parallèles. Grâce à ces registres, nous avons pu relier les 18 plaques à un seul Arduino, néanmoins plusieurs problèmes sont apparu lors de l’implémentation finale. Tout d’abord l’alimentation des trois registres à décalages était assez important et nous ne pouvions plus utiliser notre prototype en l’alimentant via le port USB d’un ordinateur. Ensuite il y avait un très grand nombre de fils entre les estrades et la stèle, 36 en tout, Cela rendait le prototype très confus, il était compliqué de brancher correctement les plaques à la stèle. Finalement cela ne fonctionnait pas surement à cause d’une erreur dans la soudure, confuse elle aussi à cause de tous les fils s’entremêlant.
Nous avons décider de trouver une nouvelle solution. Nous avons alors conçu un deux convertisseurs numériques analogiques simili R-2R grâce à des ponts de résistances. Ceux-ci se trouvent en sortie de chaque estrade et permettent de faire passer le nombre de fils entre les estrades et la stèle de 36 à 6. Cela rend aussi beaucoup plus facile le suivi de l’information, et réduit drastiquement la consommation de notre prototype. Le seul changement sur la carte Arduino est que l’on utiliser plus les pin numériques de celle-ci comme avec les registres à décalages mais les pins analogiques.
Les plaques de pression
Les plaques de pression envoient un signal jusqu’à la carte Arduino quand un des joueurs marchent dessus. Nous avions une contrainte supplémentaire des designers à propos de ces plaques, il fallait avoir possibilité de ranger l’estrade. Dans un premier temps nous voulions utiliser la déformation des plaques sous le poids du joueur grâce à des matériaux piézoélectriques mais nous avons finalement abandonner cette idée. Nous avons alors découpé de manière individuelle chaque plaque et fait un cadre de mousse, nous utilisons alors l’affaissement de la plaque et plus sa déformation. Pour transmettre le signal nous avons d’abord essayé avec un capteur de force, cela fonctionnait bien mais le prix de ce genre de capteur est trop élevé pour l’usage que l’on voulait en faire et nous nous somme rabattu sur du ruban adhésif aluminium. On pose de ce ruban conducteur en dessous de la plaque et sur un morceau de bois, on soude des fils sur ces bouts de ruban. Ainsi quand un joueur marchera sur une plaque les rubans conducteurs rentreront en contact fermant alors le circuit.
II-Ateliers éducatifs
Pour initier les enfants aux rudiment de l’électronique et de l’électronique nous avons développer des ateliers éducatifs, ces ateliers sont accompagné de fiches techniques pour que n’importe quel enseignant puisse les mettre en place. Enfin ces ateliers ont pour but final de concevoir une petite calculatrice.
Les ateliers
Nous ne disposons que de quatre séances d’une heure chacune avec les élèves de primaire. Cependant, nous avons divisé notre initiation à l’électronique et l’informatique en six ateliers plus une réalisation finale. Ainsi, la première séance est une séquence d’introduction au projet, et est également l’occasion de présenter son déroulement. Puis lors de la deuxième session, la classe est divisée en trois groupes, chaque groupe s’occupant d’un atelier découverte. Ensuite, durant la troisième séance, chacun de ces trois groupes travaille sur la conception d’une partie de la calculatrice.
Enfin, la dernière heure est consacrée à l’intégration des trois parties constituant la calculatrice pour obtenir un appareil fonctionnel. Pour ce faire, les élèves doivent, collectivement, travailler sur l’intégration des différentes parties, tout en expliquant aux personnes des différents groupes l’essentiel de ce qu’ils ont appris.
Encadrement des élèves
Les élèves de primaire sont divisés en trois groupes à chaque séance, chacun traitant un atelier. Pour chaque groupe, il y a au moins un encadrant, que ce soit un enseignant ou un membre du projet, pour accompagner les élèves dans leurs réflexions et les aider à tirer les notions que l’atelier leur permet d’acquérir.
A la fin de chaque séance, les élèves doivent faire une mise au point de leur apprentissage afin que l’ensemble du groupe bénéficie de l‘atelier.
Réalisation finale : la calculatrice
Après avoir pris connaissance des notions de base en électronique et en informatique, durant les deux premières séances, les élèves, divisés en groupe, doivent, durant la troisième séance, mettre en œuvre leurs acquis pour réaliser une partie de la calculatrice avec le matériel à leur disposition. Ils ont ainsi à opter pour une des différentes solutions possibles pour faire le travail demandé dans la partie qui les concerne. Plus concrètement, le premier groupe doit choisir les composants qu’il utilise pour construire le pavé numérique de la calculatrice, le deuxième groupe doit trouver un système de transmission de données commode et le troisième groupe a à implémenter un programme qui permet d’effectuer les opérations de base, c.à.d. l’addition, la soustraction, la multiplication et la division.
Tout au long de ce projet, les élèves sont amenés à justifier la pertinence de leurs choix auprès des encadrants.
Résumé des ateliers
Voici un résumé des différents ateliers, des activitées mises en places, des durées indicatives des ces ateliers et du support et matériel nécessaire pour faire ces ateliers.
Projet développement: L’escalier musical
Description
Dans le cadre du projet développement, nous avons réaliser un dispositif à installer sur un escalier, dispositif qui émet des notes de musique lorsqu’une personne emprunte l’escalier.
L’escalier musical
L’objectif est de favoriser l’utilisation de l’escalier traditionnel au détriment de l’escalier mécanique, afin de promouvoir l’activité physique dans notre société. L’aspect fatiguant des escaliers traditionnels est remplacé par un aspect ludique grâce à la musique, ce qui favorise son utilisation.
Matériel utilisé
- 1 Raspberry Pi B
- 3 cartes Arduino UNO
- 2 émetteurs radio FS1000A (433 MHz)
- 1 récepteur radio XY-MK-5V
- 4 modules de détection US-HC-SR04
- 1 lecteur de tag RFID RC522
Fonctionnement
L’élément prépondérant de l’escalier musical est la détection de l’usager. Pour se faire, nous utilisons les modules de détection ultrason US-HC-SR04 qui, grâce au principe d’émission-réflexion des ondes ultrasonores fournissent en continu la distance entre le capteur et un obstacle. Lorsque personne ne passe, cet obstacle est le mur opposé, et lorsqu’un obstacle se situe à une distance inférieure à un seuil, il s’agit de la jambe d’un passant et il faut donc émettre un son.
Cette tâche incombe à un Raspberry Pi modèle B qui, grâce au programme Python présenté en Annexe, émet un son lorsqu’il reçoit l’information correspondant à une marche.
Cette information transite entre le capteur ultrason et le Raspberry Pi par ondes radio grâce aux émetteurs FS1000A et au récepteur XY-MK-5V. Nous utilisons pour cela la librairie VirtualWire.
Les émetteurs sont chacun branchés à une carte Arduino UNO, où sont également branchés deux modules de détection. Ainsi, chaque émetteur transmet les informations correspondant à deux capteurs. Celles-ci sont récupérées par le récepteur XY-MK-5V, branché à une carte Arduino UNO, elle-même reliée au Raspberry Pi. Le code des cartes Arduino UNO émettrice et réceptrice est présentée en Annexe.
De plus, un lecteur de tag RFID est relié à la carte Arduino UNO réceptrice, afin de permettre aux membres de Télécom Bretagne de changer l’instrument joué grâce à leur badge. Les librairies SPI et MFRC522 sont utilisées pour cette tâche.
Le schéma suivant illustre le principe de fonctionnement de l’escalier:
Annexe
Code Python implémenté à exécuter par le Raspberry Pi:
#serial est une bibliothèque qui permet la lecture des données provenant du port série
#pygame est une bibliothèqye dont le module mixer permet de jouer des fichiers .mp3
import serial, pygame.mixer
#initialisation du mixer
pygame.mixer.init()
#initialisation de la connexion série
ser=serial.Serial(‘/dev/ttyACM1’,9600)
#la boucle sera exécutée à l’infini
while 1:
#on récuppère la valeur provenant du port série
newIncome = ser.readline()
# si c’est un instrument, on défini la variable instrument comme l’instrument correspondant
if newIncome==‘piano\r\n’:
instrument = ‘piano’
if newIncome==‘trompette\r\n’:
instrument = ‘trompette’
if newIncome==‘coeur\r\n’:
instrument = ‘coeur’
if newIncome==‘batterie\r\n’:
instrument = ‘batterie’
if newIncome==‘piano2\r\n’:
instrument = ‘piano2’
#si c’est une note de musique, on la joue grâce au module pygame.mixer
#les notes sont contenues dans un dossier dont le nom correspond à l’instrument dont elles sont issues
if newIncome== ‘A\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/la.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘B\r\n’:
pygame.mixer.music.load(‘/home/pi/Music/%s/si.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘C\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/do.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome ==‘D\r\n’:
pygame.mixer.music.load(‘/home/pi/Music/%s/re.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘E\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/mi.mp3’+instrument)
pygame.mixer.music.play(loops=0, start =0.1)
elif newIncome == ‘F\r\n’ :
pygame.mixer.music.load(‘/home/pi/Music/%s/fa.mp3’+instrument)
pygame.mixer.music.play(loops=0,start = 0.1)
elif newIncome == ‘G\r\n’:
pygame.mixer.music.load(‘/home/pi/Music/%s/sol.mp3’+instrument)
pygame.mixer.music.play(loops=0,start = 0.1)
elif newIncome == ‘c\r\n’:
pygame.mixer.music.play(‘/home/pi/Music/%s/DO.mp3’+instrument)
pygame.mixer.music.play(loops=0,start = 0.1)
Code de la carte Arduino UNO émettrice:
include <VirtualWire.h>
/* virtualWire est une librairie libre de droit permettant l’utilisation
des modules de transmission-réception radio*/
// initialisation des pins
int trig1 = 12;
int echo1 = 11;
int trig3=8;
int echo3=7;
// instanciation des variables utiles
long lecture_echo1;
long cm1;
long lecture_echo3;
long cm3;
//messages qui seront envoyés, à changer d’une carte à l’autre (msgStringD et msgStringE par exemple pour envoyer D et E)
String msgStringG;
String msgStringF;
void setup(){
// paramétrage des capteurs
pinMode(trig1, OUTPUT);
digitalWrite(trig1, LOW);
pinMode(echo1, INPUT);
pinMode(trig3, OUTPUT);
digitalWrite(trig3, LOW);
pinMode(echo3, INPUT);
//initialisation de la communication via le port série (USB)
Serial.begin(9600);
Serial.println(« setup transmitter 1 « );
//initialisation de la communication par radio
vw_setup(2000);
vw_set_tx_pin(2);
}
//code qui sera répété indéfiniment
void loop(){
// récupération de la distance cm1 du capteur 1 à l’obstacle
digitalWrite(trig1, HIGH);
delayMicroseconds(10);
digitalWrite(trig1, LOW);
lecture_echo1 = pulseIn(echo1, HIGH);
cm1 = lecture_echo1 / 58;
// récupération de la distance du capteur 3 à l’obstacle
digitalWrite(trig3,HIGH);
delayMicroseconds(10);
digitalWrite(trig3,LOW);
lecture_echo3=pulseIn(echo3,HIGH);
cm3 = lecture_echo3 / 58;
/* si la distance de l’obstacle au capteur est inférieure à 115cm et que c’est la première fois que l’obstacle
est detecté, on envoie l’information correspondant au capteur */
if( cm1 < 115 && msgStringF != « F » && cm1 != 0 ){
//traitement des données
msgStringF = « F »; /*ces valeurs seront à changer en cas de changement de carte*/
const char* msg = msgStringF.c_str();
// envoi des données par radio
vw_send((uint8_t *)msg,strlen(msg));
Serial.println(« envoyé »);
}
// sinon, on réinitialise les valeurs
elseif( cm1 >= 115){
msgStringF = « 0 »;
}
// le principe est identique pour le second capteur
if(cm3 < 115 && msgStringG != « G » && cm3!= 0){
msgStringG = « G »;
const char* msg = msgStringG.c_str();
vw_send((uint8_t *)msg,strlen(msg));
Serial.println(« envoyé »);
}
elseif( cm3 >= 115 ){
msgStringG = « 0 »;
}
delay(200);
}
Code de la carte Arduino UNO réceptrice:
#include <VirtualWire.h>
/*
* SPI et MFRC522 sont deux bibliothèques qui permettent la gestion
* du lecteur RFID
*/
#include <SPI.h>
#include <MFRC522.h>
//configuration des pins du lecteur RFID
#define RST_PIN 9
#define SS_PIN 10
//on créer une instance MFRC522
MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.
// instanciation et déclaration des variables utiles par la suite
String instruments[]={« piano », « trompette », « batterie »,« coeur »,« piano2 »};
int i = 0;
char ASCII[128];
void setup(){
// on créer un tableau de 128 char correspondant à 128 caractères du code ASCII
for(int i = 0; i<33 ; i++){
ASCII[i]= ‘ ‘;
}
ASCII[47]= ‘/’;
ASCII[58]= ‘:’;
ASCII[59]= ‘;’;
ASCII[60]= ‘<‘;
ASCII[61]= ‘=’;
ASCII[62]= ‘>’;
ASCII[63]= ‘?’;
ASCII[64]= ‘@’;
ASCII[65]= ‘A’;
ASCII[66]= ‘B’;
ASCII[67]= ‘C’;
ASCII[68]= ‘D’;
ASCII[69]= ‘E’;
ASCII[70]= ‘F’;
ASCII[71]= ‘G’;
ASCII[72]= ‘H’;
ASCII[91]= ‘[‘;
ASCII[92]= ‘ ‘;
ASCII[93]= ‘]’;
ASCII[94]= ‘^’;
ASCII[95]= ‘_’;
ASCII[96]= ‘ ‘;
ASCII[97]= ‘a’;
ASCII[98]= ‘b’;
ASCII[99]= ‘c’;
ASCII[100]= ‘d’;
ASCII[101]= ‘e’;
ASCII[102]= ‘f’;
ASCII[103]= ‘g’;
ASCII[104]= ‘h’;
ASCII[123]= ‘{‘;
ASCII[124]= ‘|’;
ASCII[125]= ‘}’;
ASCII[126]= ‘~’;
ASCII[127]= ‘ ‘;
// initialisation de la communication en série (USB)
Serial.begin(9600);
Serial.println(« setup reciever »);
// initialisation du récepteur radio
vw_setup(2000);
vw_set_rx_pin(2);
vw_rx_start();
//initialisation du lecteur RFID
SPI.begin();
mfrc522.PCD_Init();
}
void loop(){
//définition de la variable dans laquelle sera stocké le message reçu
uint8_t buf[VW_MAX_MESSAGE_LEN];
// longueur du message maximal pouvant être reçu
uint8_t buflen = VW_MAX_MESSAGE_LEN;
// si une carte est présente, on pioche dans la liste des instruments et on transmet cette information via le port série
if( mfrc522.PICC_IsNewCardPresent()){
Serial.println(instruments[i%5]);
i++;
}
// si réception du message, on le lit et on le transmet via le port série
if(vw_get_message(buf,&buflen))
{
int i;
// Message with a good checksum received, dump HEX
for(i = 0; i < buflen; i++)
{
Serial.println(ASCII[buf[i]]);
}
}
}
Mission Morse
BLANCHARD Elisa
DE VERE CAMINO Tommy
LECROISEY Clara
LIN Jifa
MOGABURE Clémence
NAMMOUR Fadi
Notre projet dans le cadre de l’intersemestre « Fablab et design » est la création d’un jeu de communication en morse pour enfants. Le principe est simple : un premier enfant reçoit des combinaisons de caractères que l’autre enfant lui envoie, en morse, avec des messages lumineux et sonores. Ces combinaisons déterminent chaque pièce, leur position et leur orientation et permettent à l’enfant d’assembler des pièces dans une forme donnée. Une fois toutes les pièces correctement assemblées, les enfants reçoivent un message sur un écran LCD accompagné de signaux sonores et lumineux.
Conception, fabrication d’une fraiseuse à commande numérique
Conception, fabrication d’une fraiseuse à commande numérique
Depuis déjà quelques années, je souhaitais construire une machine multiaxes pour la commande numérique. Avec l’arrivée des imprimantes 3D dans le domaine des makers et du grand public, des projets open source ont vu le jour et il est devenu de plus en plus aisé de construire de toutes pièces ou en kit ce genre de matériel.
N’ayant pour expérience que celle acquise au FabLab de Telecom Bretagne, je partais d’une faible connaissance des machines multiaxes et en construire une demandais quand même quelques bases. Fin juillet 2015, le site hackaday publie un article sur la réalisation de [joekutz] : desktop sized CNC from hardware store : http://hackaday.com/2015/07/22/desktop-cnc-from-hardware-parts-really-makes-the-cut/. Ce post me donne alors l’envie de développer ma propre machine à commande numérique. Je peux alors profiter du retour d’expérience de [joekutz] pour me lancer dans l’aventure !
Réflexions sur la conception de la CNC
Je commence mon apprentissage par le visionnage des vidéos proposé par l’auteur. Plusieurs critères sont importants dans la réalisation de ce type de machine : la précision et la stabilité des éléments mobiles sont bien entendu les facteurs significatifs de la réalisation. [Joekutz] propose l’utilisation de coulisses de tiroir pour réaliser les guides des translations d’axes. J’ai également opté pour cette solution, certes coûteuse mais d’une rigidité plus qu’efficace lorsqu’on choisit les bonnes glissières. En effet, en fonction de la charge supporté par un tiroir, une glissière peut être composée d’une cage comportant jusqu’à 2 x 8 billes de roulement. Afin d’éviter un jeu excessif des parties mobiles, je choisi d’utiliser deux de ces coulisses par axe. D’autres solutions étaient également envisageables, notamment l’utilisation de stubs en acier rapide, ainsi que de roulements colinéaires mais dans un souci de facilité de conception j’ai choisi la première approche.
J’adopte également une bonne partie des éléments électromécaniques proposés par l’auteur de l’article, en particulier les moteurs NEMA17 pas à pas et les contrôleurs Big Easy Stepper Motor Driver, tous deux faciles à trouver sur les sites de vente en ligne habituels. C’est décidé, ma machine à commande numérique sera à plateau mobile, axe Z fixe en X et Y. Concernant le logiciel au cœur de la machine, j’ai découvert le fabuleux projet GRBL : https://github.com/grbl/grbl/wiki open source et dédié au contrôle des machines multiaxes. En quelques mots, GRBL se télécharge sur un Arduino Uno correctement câblé aux différents contrôleurs et actionneurs de la machine pour agir comme passerelle entre la réception des commandes envoyées par le PC et les moteurs. C’est un programme qui exploite au maximum les capacités de la carte et qui implémente des réglages utilisateur, des interruptions fin de course, la possibilité de travailler en métrique ISO ou Impériale, etc.
Développement de la maquette électromécanique
J’ai commandé toutes les pièces de la machine d’un coup afin de travailler sur mon projet sans délais entre deux fabrications. Une fois chaque élément reçu, j’ai cherché à développer un prototype de démonstration pour vérifier que le logiciel GRBL, dans sa version de base – uniquement avec les contrôleurs et les moteurs, échangeait correctement avec le matériel et l’ordinateur. J’ai ainsi construit un prototype avec la carte Arduino, les Big Easy Drivers et les NEMA17, l’alimentation à découpage et le convertisseur DC-DC. Une fois la démo montée, j’ai pu vérifier que chaque moteur répondait à la commande envoyée depuis le PC avec le langage Gcode. Pour éviter d’envoyer à la main chaque commande, j’ai téléchargé l’application GRBL Controler qui me permet de commander la machine depuis l’interface graphique.
Conception et fabrication de la machine
Une fois le fonctionnement de GRBL démontré sur la maquette, j’ai entamé la construction des parties mécaniques de la machine. Pour la structure de la machine j’ai choisi d’utiliser des panneaux de médium sous forme de chutes pour des contraintes de budget. Ce type de bois n’est pas optimal mais il a cependant l’avantage de se présenter sous forme de planches plus rigide que le contreplaqué de même épaisseur. J’ai donc acheté des chutes de MDF de 16 à 18 mm d’épaisseur. La base de la machine se compose de deux panneaux de 350 * 350 mm vissés entre eux. Dans la configuration adoptée, la base fixe indéniablement la taille maximale de traversée du plateau mobile en X et en Y. On disposera d’une surface au maximum 4 fois inférieure à la taille de la base, soit 350/2 * 350/2 mm.
Je monte ensuite ce qui devient l’axe X sur la base. Il se compose de deux glissières avec cage à roulements pour le guidage, d’une tige filetée de diamètre 8 mm pour l’avance linéique, ainsi qu’un roulement guide pour l’effort dans le sens de l’axe et le moteur pas à pas. Je commence par monter l’embase des glissières, préalablement découpées à 200 mm. Elles sont espacées de 100 mm et doivent être parfaitement parallèles pour éviter les efforts latéraux sur les billes. Pour faire, je commence par contraindre un seul côté des glissières à l’aide de vis à bois serrées. Cela me permet dans un premier temps de régler l’angle nul entre les deux bases avec un réglet. Dans un second temps, j’utilise un pied à coulisse numérique pour mesurer l’écart relatif de part et d’autre de la base des coulisses. Une fois que le réglage est fait, j’obtiens moins de 5/100 mm d’écart entre les deux extrémités. Pour ne pas perdre cette précision lors du vissage des extrémités opposées, je forme un guide de foret avec un pointeau puis je réalise un trou guide d’1.5 mm de diamètre pour y mettre les vis à bois. Les deux glissières sont alors parallèles.
Je passe ensuite à l’installation du plateau de l’axe X sur la partie supérieure des glissières. J’ai rencontré plusieurs problèmes sur cette partie. Premièrement, je ne pouvais plus utiliser de vis à bois car l’épaisseur du plateau était trop faible pour les serrer suffisamment. J’ai donc opté pour des boulons de diamètre 3 mm ainsi que de rondelles de taille similaire. Afin de ne pas dépasser l’épaisseur du plateau d’axe, j’ai creusé l’intérieur du plateau avec une fraise de 15 mm. Deuxième problème : comment aligner les glissières sur le plateau ? Pour cela, j’ai d’abord essayé de fixer les pièces avec de la colle chaude. Echec. La colle adhère très bien au bois, mais ne tiens pas sur le métal, même en le limant. La colle à bois fût la solution à ce problème. Les coulisses installées, il reste à monter la tige filetée, le roulement, le moteur et l’écrou d’axe. Le support du roulement à billes est réalisé avec deux rondelles acier de 40 mm, avec 3 trous espacés de 120 °. C’est la bague extérieure du roulement qui est retenue par les rondelles, ces dernières sont montées sur la base de la machine avec des renvoi d’angle en acier. La tige filetée est ensuite serrée sur la cage intérieure du roulement par deux écrous M8. Cette partie assure une grande rigidité dans le sens de l’axe. Le moteur pas à pas est quant à lui monté sur une plaque rigide en acier, elle-même vissée sur la tranche du la base de la machine. Un raccord souple est utilisé pour relier la tige filetée de 8 mm à l’arbre 5 mm du moteur. Enfin, le guide mécanique du plateau X est réalisé via deux écrous papillon tête- bêche, percés et vissés.
L’axe Y est ensuite réalisé de la même manière, avec pour contraintes supplémentaires l’épaisseur de tranche plus faible pour la plaque moteur, moins de place pour le roulement à bille et le besoin indispensable d’être parfaitement d’équerre avec l’axe X. Le plateau mobile monté sur la cascade des deux axes est muni d’un support « sacrificiel » qu’il sera possible de remplacer s’il s’abime à cause de fausses manipulations.
Je m’attaque ensuite à la construction de l’axe verticale. Plusieurs éléments sont à prendre en compte : l’ensemble monté doit être parfaitement rigide (suffisamment fixé à la base), l’axe Z doit être piloté comme les deux axes horizontaux et le plateau doit bien sûr être mobile. Le support est construit avec les mêmes panneaux de médium, et l’axe utilise les glissières métalliques de tiroir. Comme pour les deux axes précédents, je commence par monter la base des glissières sur le support puis je contraints le reste sur la partie mobile. Le moteur pas à pas est ensuite fixé grâce à un déport collé sur le support. L’ensemble tige filetée plus guide mécanique et raccord souple est monté de la même manière que précédemment. Le tout est ensuite solidarisé à la base de la machine à l’aide de 4 morceaux de profilé carré de 20 mm en aluminium.
Il reste ensuite les interrupteurs de fin de course, utilisés à la fois pour éviter que le plateau ne sorte de sa zone de fonctionnement et pour réaliser le « homing », un mécanisme qui permet de réactualiser les positions absolues de la machine. Dans une optique de recyclage, j’utilise des interrupteurs « simple position » soudés sur un morceau de plaquette pré percée puis visée sur un renvoi en L métallique. Lorsque le plateau ou l’axe Z part en butée, une tête de vis force le contact sur l’interrupteur et GRBL coupe toute activité des moteurs pas à pas. Dans le cas du homing, le logiciel force les axes à partir en butée d’origine ce qui permet de définir la position [X0 Y0 Z0] de la machine.
Pour l’outil de fraisage, je dispose d’une Dremel like peu utilisée (et de piètre qualité, je la changerai plus tard…) qui est tout indiquée pour le travail. L’outil sera donc installé sur l’axe Z de la machine, tangent au plateau mobile.
Pour cela, je réalise 2 supports en bois qui viendront pincer la mini perceuse. J’ai d’abord dessiné les dimensions de la pièce avec un outil de DAO/CAO puis j’ai reporté le résultat sur de morceaux de medium. Le reste n’était qu’une affaire de découpe avec la scie à araser pour les lignes droite et la scie à chantourner (à la main) pour les courbes et la découpe intérieure. Deux perçages extérieurs permettent de fixer le support et un perçage sur la partie flexible permet de serrer l’étau autour du corps de la perceuse. Je voulais également pouvoir changer l’outil sur la CNC, ce qui m’a poussé à fixer les supports sur une plaque intermédiaire, elle-même fixée à l’axe Z. Je peux alors retirer la plaque avec les supports dessus, et en ajouter une nouvelle avec de nouveaux outils (une buse d’imprimante 3D ? ;-).
C’est terminé pour la construction ! Je peux enfin tester le matériel :
Retour d’expérience
Après avoir construit cette machine, il y a quelques points que j’aimerai soulever. Tout d’abord, l’utilisation du bois comme matière première de construction n’est vraiment pas optimal. Sans forcément parler de contraintes mécaniques, je pense plutôt à l’usinage de certaines matières qui nécessitent une lubrification. J’ai été confronté à l’usinage de verre synthétique de type Polyglass et dérivés qui, contrairement au Plexyglass, est fait de polypropylène. Cette matière est compliquée à usiner car le polypropylène fond et colle sur l’outil s’il n’est pas correctement refroidi. C’est un problème récurrent, même dans les secteurs industriels. Après, la machine ici fabriquée était plus un « proof of concept » qu’un modèle final pour vente. L’utilisation d’aluminium plutôt que du bois aurait astronomiquement augmenté le prix et la complexité de la fabrication.
Ensuite, deux problèmes en un, lorsque j’ai câblé les interrupteurs de fin de course pour la première fois, ceux-ci fonctionnaient très bien. J’ai ensuite essayé d’usiner un bout de circuit imprimé et à chaque démarrage du processus de fraisage, la machine s’arrêtait brusquement. Après de nombreuses minutes de recherches, le problème venait de la mini perceuse qui génère une quantité astronomique d’impulsions électriques (moteur à charbons) à cause des étincelles. Les perturbations remontaient sur les câbles non blindés des interrupteurs de fin de course et causaient des interruptions sur le microcontrôleur. Une fois les interrupteurs débranchés, le cycle retournait à la normale. Je devrais donc par la suite changer les fils de connexion par des câbles blindés, et si possible changer la perceuse par un moteur brushless dédié au fraisage.
Enfin, quelques problèmes de dimensionnement. J’ai construit cette machine sans réellement connaître à l’avance les dimensions, la façon dont tout allait s’ordonnancer. Avec du recul, le plateau mobile n’est pas une solution très efficace car la base de la machine doit être au moins 4 fois supérieure. Or, avec une base de 35 cm x 35 cm, j’obtiens un plateau de surface inférieure à 14 cm x 14 cm. Cette limitation vient des raccords souples sur les moteurs pas à pas et de la taille des plateaux. L’axe Z quant à lui est monté beaucoup trop bas sur la machine, ce qui empêche de travailler avec des pièces de hauteur supérieure à 4 cm. Pour une prochaine machine à commande numérique, je fabriquerai un plateau fixe muni d’un axe Z capable de se déplacer latéralement. La surface min devra alors être de 1 m x 1 m.
Quelques points positifs pour conclure, cette machine a quand même été construite en un temps raisonnable (2 semaines) pour un total d’environ 120 h. Le prix final de la CNC s’élève à 200 € en comptant les outils spécialement achetés pour l’occasion. Les tests n’auraient jamais été réalisés aussi rapidement sans le logiciel open source GRBL. C’est une machine qui fonctionne très bien pour ce qu’on lui demande de faire, et parfaitement en accord avec les pratiques Do It Yourself.
Melvin PROST
