DobotNet Arduino – Réseau de robots Dobots Magician

Publié le 1 juin 2023 par Byron Cholet

Bienvenue à toutes et à tous !

Dans cet article, nous allons partager avec vous les découvertes que nous avons faites lors de notre projet de deuxième année de classe préparatoire à Polytech Angers !

Ça, c’est ce qu’on a fait…

Vidéo de démonstration du projet DobotCity, by DobotNet

Oui oui, nos deux petits bras robotisés essaient de construire une ville miniature… Vous voulez savoir comment ? Et bien c’est parti !

1. Présentation du matériel

Notre objectif lors de ces six derniers mois était de créer une solution pour permettre la communication entre plusieurs Dobots Magician via une carte Arduino.

Les Dobots Magician sont des petits robots comme celui-ci, auxquels on peut ajouter une extension telle qu’une ventouse ou une pince pour attraper des objets, un crayon pour dessiner, ou même un laser pour graver dans la matière !

Ils ont une portée allant de 15cm à 32cm par rapport à leur base et une répétabilité des mouvements de 0.2mm.

La carte Arduino MEGA va agir comme le cerveau de notre projet. Elle se verra attribuer diverses lourdes tâches comme relayer les informations entre les Dobots, mémoriser l’avancement de la construction de la ville, recevoir des commandes de la part de l’utilisateur…

Au début, nous avions une carte Arduino UNO, mais elle n’avait pas assez de RAM pour assumer toutes ces responsabilités, nous n’avons donc pas eu d’autre choix que de la changer !

Source de beaucoup d’ennuis, certes, mais la construction de notre ville ne pourrait pas se faire sans la caméra…

En effet, nous allons avoir besoin de repérer des cubes dans l’espace, elle sera donc utile pour traiter le flux d’images qu’elle capture et récupérer en temps réel des informations précieuses que nous allons aborder dans quelques instants.

2. Choix du projet

Comme nous l’avons expliqué, notre but lors de ces six derniers mois était de parvenir à faire collaborer deux Dobots Magician connectés à une carte Arduino. Nous souhaitions profiter au maximum de ces 100 heures de projet pour découvrir de nouveaux domaines liés à l’informatique, il est donc évident que le projet que nous vous présentons aujourd’hui ait piqué notre curiosité. Voici quelques raisons pour lesquelles nous avons choisi ce projet au-dessus des autres :

Satisfaction visuelle offerte par le travail en équipe de deux robots lors de la réalisation d’une tâche complexe
Publication en source libre pour apporter sa participation au développement de la communauté Dobot
Découverte de pratiques courantes en robotique qui seront nécessairement utiles dans le futur
Introduction et apprentissage autonome à la vision par ordinateur
Familiarisation avec du matériel électronique

Enfin bref, c’est finalement la liberté offerte par ce projet, que ce soit dans sa finalité comme dans les procédés pour l’atteindre, qui nous l’a fait remarquer au-dessus des autres.

Maintenant que vous savez pourquoi on l’a choisi, voyons comment nous nous y sommes pris pour construire une petite ville.

3. Premiers pas : Découverte de DobotStudio

Nous avons passé les premières heures de projet à expérimenter et à nous familiariser avec les robots grâce à l’interface de contrôle DobotStudio. Cette application propose de nombreux modes amusants et interactifs pour faire se mouvoir les Dobots. On retrouve notamment le Teach and Playback, où le robot exécute une série de mouvements prédéfinis, et le Write and Draw, qui laisse le robot dessiner un texte ou une image téléversée sur l’application.

En revanche, le mode qui nous intéressait réellement pour le début de ce projet était la programmation en Blockly, puisqu’il offre un accès simplifié aux commandes d’un Dobot grâce à des blocs préprogrammés. En seulement quelques minutes, nous pouvons créer le programme ci-dessous:

Illustration des mouvements d’un Dobot avec DobotStudio | Programme Blockly

Le résultat obtenu lors de l’exécution de ce programme est le suivant :

Illustration des mouvements d’un Dobot avec DobotStudio | Vidéo

Avec quelques essais supplémentaires, nous avions une bonne appréhension de la manière de se déplacer des Dobots. Il était donc temps de passer à l’étape suivante : leur interface de communication.

4. Communication en série avec les Dobots

Nous vous l’avions caché jusqu’à maintenant, mais nos petits robots disposent de diverses interfaces de connexion. La zone 6 sur la photo ci-dessous permet l’alimentation et le contrôle des extensions telles que la ventouse ou la pince.

En revanche, celle qui nous intéresse actuellement est l’interface de communication en zone 3. Parmi les 10 pins exposés dans cette zone, 2 d’entre eux (nommés RX et TX) constituent une interface UART, qui permet le transfert bidirectionnel et asynchrone de données en série.

Cette interface est d’autant plus intéressante qu’elle peut être associée à l’une des quatre interfaces UART installées par défaut sur une carte Arduino MEGA (entourées en rouge). Pour ce faire, il suffit de connecter les pins RX et TX à l’arrière du Dobot respectivement aux pins TX1 et RX1 de la carte Arduino. Une troisième connexion nécessaire est celle entre le GND de l’Arduino et celui du Dobot.

Une fois cette connexion réalisée, l’Arduino peut, avec le programme approprié, envoyer des commandes au robot à laquelle elle est liée.

Après quelques heures de recherche, nous sommes entrés en possession de deux fichiers importants. Le premier détaille le protocole de communication des Dobots (format des paquets de données) et contient une liste de leurs commandes enregistrées. Le second est un programme de démonstration faisant bouger un Dobot en connectant ses pins RX et TX à une carte Arduino MEGA.

Voici le résultat obtenu grâce au code de démonstration :

Une très bonne nouvelle pour nous fut que cette démonstration contenait l’implémentation d’une dizaine de commandes et d’un système assez modulaire (bien que parsemé de bugs embêtants) pour établir une communication à double sens avec un Dobot.

Après avoir passé plusieurs heures à lire, comprendre et corriger le code de démonstration, nous étions fin prêts à relever notre plus gros défi jusqu’à présent : la création d’une bibliothèque open-source pour permettre le contrôle de un ou plusieurs robots Dobot Magician depuis une unique carte Arduino Mega.

Démonstration Arduino

5. Création de DobotNet

C’est ici que naquit DobotNet. Avec un temps considérable passé à découvrir et à réorganiser la démonstration, nous avons été capables de marquer les parties du code nécessitant une réécriture complète et celles pouvant être utilisées sans grosse modification.

Il s’agissait de notre première expérience de création d’une bibliothèque open-source. Aussi, nous avons concentré nos efforts pour améliorer au maximum la lisibilité du code grâce à des fonctions documentées et simples à utiliser.

Voici l’évolution de la syntaxe pour faire se déplacer un robot vers un point donné, en commençant avec la méthode initialement proposée par la démonstration :

// Long, peu pratique et sans support pour plusieurs Dobots
PTPCmd gPTPCmd;
gPTPCmd.x = 200;
gPTPCmd.y = 0;
gPTPCmd.z = 0;
SetPTPCmd(&gPTPCmd, true,  &gQueuedCmdIndex);

Et maintenant, l’équivalent du code précédent en utilisant DobotNet, où “dobot” est une variable pouvant représenter n’importe lequel des robots connectés à la carte :

dobot.MoveTo(MOVL_XYZ, 200, 0, 0, 0);

En comparant ces deux extraits, on remarque que le gain de temps, de place et par conséquent de lisibilité du code source n’est pas négligeable, surtout pour des procédures de mouvements plus longues et complexes.

Nous avons également ajouté des exemples à notre bibliothèque DobotNet pour permettre une prise en main rapide et accompagnée. Elles vont d’une simple reproduction de la démonstration sur laquelle est basée notre bibliothèque, au code complet de la solution dont vous avez vu un extrait au début de cet article. On retrouve ci-dessous le résultat de l’exécution de l’exemple “NetworkDemo.ino”

Exécution de l’exemple NetworkDemo.ino avec DobotNet

6. Création de la ville

Maintenant que nous pouvons facilement faire bouger nos Dobots, passons à la création de notre ville. Pour ce faire, il nous faut dessiner un plan aux proportions suffisamment impressionnantes pour l’aspect visuel, tout en restant dans la portée des robots. Il faut également faire attention à ce que les structures dans la ville ne soient pas trop proches les unes des autres pour s’assurer que l’ouverture de la pince ne démolisse pas des bâtiments adjacents.

Plusieurs versions ont été nécessaires, mais nous sommes finalement parvenus à un plan satisfaisant nos attentes :

Chaque couleur représente un type de bâtiment :

Maison (rouge) [2×1]
Arbre (vert) [2×1]
Immeuble (jaune) [3×2]
Voiture (bleu) [1×2]
Zone de transition (blanc)

La zone de transition est un emplacement auquel les deux Dobots ont accès, permettant le transfert des blocs d’une zone à l’autre.

En plaçant la tête du Dobot sur le point de calibration (rouge) au centre de l’image, nous pouvons récupérer un point de référence dans le système de coordonnées du Dobot, ce qui permet de convertir les coordonnées en millimètres des bâtiments. Il en est de même pour le Dobot de la partie suivante.

7. Création de la zone de stockage

Nous entrons maintenant dans la partie qui s’est avérée être la plus problématique de toutes pour notre projet : la zone de stockage. Il s’agit de l’endroit où les blocs sont déposés par l’utilisateur, pour ensuite être récupérés par un Dobot et placés sur la zone de transition. C’est maintenant que nous faisons appel à la caméra, dont la capture sera traitée pour essayer de déterminer la position des blocs dans la zone de stockage.

Voici ce à quoi ressemble notre zone de stockage (Théorique | Capturée par la caméra) :

Les quatre carrés noirs étranges autour de la zone de stockage sont appelés des marqueurs Aruco. Ils sont parfois utilisés en vision par ordinateur pour délimiter une zone, déterminer un repère ou traquer un objet mobile.

En utilisant la bibliothèque de traitement d’image OpenCV (Open Computer Vision) disponible sur Python, nous pouvons réaliser les étapes suivantes pour isoler la zone de stockage et détecter les cubes.

1) Trouver le centre des marqueurs Aruco sur l’image avec cv2.aruco.detectMarkers()

2) Transformer l’image de sorte que les centres trouvés soient aux coins de l’image avec cv2.getPerspectiveTransform(centres, coins) et cv2.warpPerspective(). Le résultat est présenté ci-dessous :

Image de la zone de stockage après transformation de la capture

3) Appliquer un flou gaussien pour réduire le bruit

4) Appliquer un algorithme de détection des contours avec cv2.Canny() et deux paramètres sélectionnés par l’utilisateur. Nous avons créé une interface qui permet de visualiser l’effet des deux paramètres (En vert sont les contours détectés)

Interface de calibration des paramètres de la caméra

5) Validation des dimensions des contours, calcul des centres et de la couleur des blocs

6) Compilation des résultats dans l’interface de contrôle

Il nous aura fallu beaucoup de temps pour comprendre les fonctions proposées par OpenCV et trouver une combinaison d’algorithmes donnant un résultat fiable. Nous avons cependant découvert de nombreux concepts en lien avec la manipulation d’image qui ont changé notre perception de ce domaine.

8. Interface Utilisateur Graphique (GUI)

Comme nous venons de le voir sur les deux captures précédentes, nous avons ajouté à notre projet des interfaces utilisateur pour faciliter le contrôle depuis un ordinateur. Ces interfaces ont été réalisées avec Tkinter. Chaque bouton sur l’interface de contrôle communique une commande à la carte Arduino via un module Bluetooth que nous avons ajouté. Un exemple simple est le bouton Construire qui permet de lancer / arrêter la procédure de construction de la ville, ou le bouton Reset qui permet de recommencer la procédure de zéro.

Nous avons également ajouté un écran LCD 4×20 connecté à l’Arduino pour afficher l’état actuel de la procédure. Le voici dans deux états différents :

9. Perspectives d’amélioration

Comme nous vous l’avons expliqué au début de cet article, l’une des raisons principales pour laquelle nous avons choisi ce projet est sa capacité à constamment pouvoir être amélioré. Nous avions de nombreuses idées pour compléter le travail que nous avons fait jusqu’à présent, mais le temps nous a manqué pour réaliser certaines d’entre elles.

Nous souhaitions par exemple imprimer une carte électronique pour réduire le nombre de câbles apparents qui dégradent actuellement l’apparence extérieure de notre projet, mais par manque de temps, nous n’avons pas eu l’occasion d’aller au bout de cette idée.

Prototype de carte électronique, réalisée sur EAGLE by AutoDesk

Sans carte électronique et par conséquent sans certitude des dimensions, nous ne pouvions pas prendre le risque d’imprimer une boîte de rangement pour la carte Arduino et les modules qui y sont connectés.

Enfin, une dernière amélioration que nous aurions réellement aimé ajouter est celle laissant l’utilisateur dessiner sa propre ville. Elle correspond au bouton Dessiner sur l’interface de contrôle. Seul le temps pour créer une interface de dessin du plan nous manquait, puisque le code Arduino est déjà adapté pour accueillir ce genre de fonctionnalité.

10. Bilan

Si vous êtes encore là, merci beaucoup d’avoir pris le temps de lire cet article !

Ce projet a été pour nous une expérience inoubliable. Même si, comme nous venons de le voir, nous n’avons pas eu le temps d’aller au bout de nos perspectives, nous sommes tout de même très heureux du travail accompli lors de ces six derniers mois. Nous n’étions que deux pour réaliser ce projet, et les défis que nous a causé notre ambition ont été de taille. Même si notre technique pour aborder certains problèmes n’était pas parfaite, nous sommes fiers d’avoir accompli ce qui est notre projet aujourd’hui.

Vision par ordinateur, programmation sur Arduino, création d’une bibliothèque, design d’une carte électronique, modélisation 3D. Toutes ces compétences ne pourront que nous être bénéfiques pour le futur, et nous garderons un très bon souvenir de ce travail d’équipe pour surmonter les obstacles rencontrés sur le chemin.

11. Remerciements

Nous remercions évidemment l’ensemble des enseignants qui ont pu nous aider durant ce projet, et plus particulièrement :

Mr. BOIMOND Jean-Louis, notre référent de projet
Mr. LAGRANGE Sébastien
Mr. VERRON Sylvain

Ce projet a demandé beaucoup de rigueur, il aurait donc été impossible sans leur aide précieuse.

12. GitHub Repositories

DobotNet : https://github.com/MisTurtle/DobotNet
DobotCity, by DobotNet : https://github.com/MisTurtle/DobotCityBuilding
ArucoCrop : https://github.com/MisTurtle/ArucoCrop_Library

Kind Regards, us

by Paquereau–Gasnier Alexis, Cholet Byron

Bombe factice

Publié le 31 mai 2023 par Matthias Lehouelleur

L’objectif de ce projet était de réaliser une fausse bombe à désamorcer, un genre d’escape game, c’est à dire qu’une suite d’étapes doit être réalisée dans un certain ordre avec deux erreurs maximum pour finir le jeu. Pour cela, nous étions 3, avions 100 heures et une totale liberté des énigmes.

Mais pourquoi avons nous choisi ce projet?

Tout d’abord, nous recherchions un projet qui nous permettait de créer quelque chose de concret. Ensuite nous avions un attrait particulier pour la programmation et nous aimions manipuler les composants électroniques. C’est pour cette raison que lorsqu’on nous a proposé le projet de bombe factice, nous avons tout de suite adhéré à l’idée. Mais pour concrétiser notre projet, il nous a fallu passer par différentes étapes et surmonter quelques difficultés.

Intérieur de la version finale du projet

Brainstorming

La première étape était le brainstorming. Durant les trois premières heures, nous avons d’abord discuté et débattu en groupe pour nous mettre d’accord sur la trame à suivre pour désamorcer la bombe ainsi que sur son apparence.

Recherche et commande

Ensuite, après cette étape de mise en commun des idées, nous avons créé une liste avec tous les composants nécessaires à la décoration ainsi qu’au bon fonctionnement de la bombe. On a donc commencé nos recherches pour trouver les composants. On s’est vite rendu compte qu’une modélisation 3D était primordiale. En effet, il existe des composants ayant la même fonction mais avec des tailles bien différentes. Or nous avions comme contrainte la taille de notre mallette. Donc, il fallait trouver les composants appropriés pour pouvoir garder une mallette de taille abordable. Une fois cette étape finie, nous avons envoyé notre liste à notre responsable de projet (Mr. Sébastien Lagrange). Il s’est occupé d’effectuer la commande. Après la réception des produits, nous devions entamer notre partie préférée : la manipulation.

Programmation de chaque élément

Nous avons alors commencé à créer un programme pour réaliser la trame de désamorçage de la bombe. Pour cela, il nous a fallu prendre chaque élément indépendamment pour comprendre comment il fonctionne et ainsi pouvoir mieux le contrôler après. Durant cette étape, nous avons rencontré plusieurs défis à relever car nous avions seulement de petites bases sur le langage que nous utilisions (Arduino). Mais, à chaque fois grâce à nos recherches et à l’aide de nos professeurs, nous avons pu résoudre nos problèmes et finaliser ce code.

Exemple de code, ici, une partie du code du jeu du Simon

Création de l’intérieur de la mallette

Pour la création de l’intérieur de la mallette, nous avons utilisé plusieurs machines et plusieurs procédés de fabrication (par exemple l’impression 3D , le découpage par laser et l’impression de stickers). Le but premier était de maintenir les composants et de rendre l’intérieur de la mallette esthétique pour qu’ elle ressemble à une bombe à désamorcer. Nous avons donc par exemple rajouté une fiole contenant un liquide fluorescent. Ensuite, nous avons découpé une tablette pour fixer tous les composants et cacher la partie électronique. Nous avons réalisé le montage , et nous avons fait les soudures sur la carte électronique. Nous avons bien sûr aussi peint.

Impression d’un des bouchons pour la gourde

Création de la carte électronique

La création d’une carte électronique était obligatoire pour éviter de garder les breadboards (plaquettes permettant de connecter facilement des fils), qui sont uniquement destinés aux prototypes. Nous avons donc dessiné le schéma d’une carte électronique. Cependant, des camarades sont venus nous prévenir que nous ne respections pas des règles obligatoires (la taille des pistes par exemple) pour que la machine puisse la découper. Une nouvelle version a donc dû être faite. Or cette fois ci, c’est un professeur qui nous a indiqué encore d’autres problèmes, comme des pistes trop proches. La troisième et dernière version fut la bonne. Après un bon moment de soudage des connecteurs, nous avons pu passer à l’assemblage.

Assemblage

L’assemblage a été une étape plus longue que prévue. En effet, nous nous imaginions que nous allions simplement mettre tous les modules d’épreuve dans la mallette et que cela allait fonctionner au premier essai. En réalité, nous avons eu un certain nombre de problèmes, comme les boutons lumineux qui ne fonctionnaient plus, l’écran qui n’affichait plus rien et a donc dû être changé ou encore des fils qui s’arrachaient lors de la fermeture de la mallette. Ces derniers problèmes ont pu être résolus, rendant ainsi notre projet fonctionnel.

Dernières soudures avant de tout faire rentrer dans la mallette

Bilan

Nous sommes tous très fiers du travail que nous avons réalisé ainsi que du produit fini. En effet, pendant toute la durée du projet, nous nous sommes bien entendus et nous avons plutôt bien réparti les tâches entre chaque membre du groupe. De plus, le produit final est esthétique, aéré et agréable à manipuler. Il respecte le cahier des charges que nous nous sommes fixé au début du projet, à l’exception de l’énigme qui devait permettre d’ouvrir la mallette. Nous avons décidé de ne pas la mettre en place en cours de création car cela ne nous paraissait plus intéressant. En effet, cela nous aurait obligé à afficher quelque chose au-dessus de la mallette et nous avons pensé que cela serait plus judicieux de laisser la mallette comme nous l’avions reçue.

Merci de nous avoir lu

Matthias LEHOUELLEUR
Alan MARTINIER
Maël JUGDE

Système de stationnement automatique avec Arduino

Publié le 31 mai 2023 par Margot Le Moal

Système de stationnement automatique

Bonjour à tous et bienvenue dans notre article.

Nous sommes Maxence, Victor et Margot, trois étudiants en 2ème année du cycle préparatoire intégré de Polytech Angers. Notre projet consiste à concevoir et mettre en place un système de stationnement basé sur Arduino (une maquette d’un parking automatisé). C’est à dire que la barrière s’ouvre et se ferme toute seule quand elle détecte une voiture. Les contraintes sur ce projet étaient de programmer avec Arduino, que le système doive permettre la gestion de stationnement: nombre des places inoccupées qui doivent être affiché sur un écran, la durée de stationnement (en heure) et le prix de stationnement pour chaque voiture garée dans le parking.

Pourquoi avons nous choisie ce projet ?

Nous avons choisie ce projet car il permettait de toucher à tous les domaines : la conception, la programmation, la réalisation, l’impression 3D, etc. De plus, nous ne savions pas quelle spécialité choisir, donc travailler sur ce projet pouvait nous aider dans notre choix.

Étape de notre projet

Analyse fonctionnelle du système et de ses contraintes
Recherche de normes sur les vrais parkings
Recherche sur la maquette (pièces électroniques et planches)
Programmation sur Tinkercad
Devis
Fabrication pièces CAO
Construction maquette

Première phase: la recherche

Nous avons commencé notre projet par une phase de recherche, nous avons mis en commun nos idées sur le meilleur parking et ce que nous voulions faire. Tout d’abord nous avons fait un schéma fonctionnel pieuvre, que vous pouvez retrouver ci dessous. Grâce a cela nous avons eu une vision des contraintes : l’écologie, le prix, l’esthétique, etc.

Ensuite nous avons fait un peu de recherche sur la construction d’un vrai parking, afin de respecter au mieux les normes est les dimensions.

La réflexion sur notre maquette

Après ces recherches, nous avons choisi à quoi notre maquette de parking allait ressembler. Nous voulions que le parking ait un étage, deux places handicapées ainsi que deux places électriques. Il y aura 23 places classiques avec une entrée et sortie différente. Les places libres seront indiqué grâce à deux écrans.

Nous avons fait plusieurs devis et commandes d’électronique et de bois pour la structure du parking.

Programmation sur Arduino

Au début nous avons utilisé le logiciel TINKERCAD avons d’avoir les composant. Ce logiciel est un simulateur Arduino avec les composant et la partie programmation. Cela nous a permis de commencé la programmation.

Ensuite nous avons programmé sur Arduino par l’intermédiaire d’une carte Arduino méga.

Conception support 3D

Nous avons principalement utilisé le logiciel SOLIDWORKS, c’est un logiciel de CAO très utilisé à Polytech. Nous y avons construit tout nos panneaux de signalisation ainsi que la barrière et un boitier pour couvrir les câbles et y mettre l’entrée et la sortie. Le point positif avec l’impression 3D est que l’on pouvait vraiment créer les pièces que nous voulions avec les mesures désirées.

Conception de la maquette

Une fois toutes nos planches reçues, nous avons commencé la construction de la maquette.

La première étape était de tracer toutes les places et passages sur les planches au crayon de bois. Cela nous a permis de voir comment rendait le parking et de faire quelque changement comme agrandir l’espace pour les barrières. Nous avons fait cela sur les deux planches.

Ensuite nous avons dimensionné et coupé les poteaux permettant de surélever le parking et de créer l’étage.

Après nous avons installé les capteurs et écrans (toutes l’électronique). Nous avons décidé de faire passer tous les fils sous la maquette pour que le rendu soit plus propre. Donc il a fallu faire plusieurs trous pour faire passer les capteurs.

En parallèle, nous avons imprimé les panneaux 3D ainsi que les barrières de protection et les barrières d’ouverture. Nous avons aussi créé des cartes de différentes couleurs avec des planches de bois et des stickers que nous avons conçu. Ces cartes vont permettre d’être reconnues par les capteurs couleur à l’entrée et à la sortie du parking, cela permet de simuler les cartes d’abonnement d’un parking réel.

Pour finir, nous avons tout fixer : les piliers sur l’étage, panneaux, barrière et toute la partie électronique, ainsi que repasser au crayon Posca tous les marquages. Notre maquette est prête ! Maintenant c’est le moment de tester. Nous vous avons mis ci-dessous une vidéo du fonctionnement complète de la maquette.

vidéo du fonctionnement du capteur couleur

Merci à vous !!!

La boite à histoire

Publié le 30 mai 2023 par Maxime Lambert

Répondre

Notre projet s’intitule “boîte à histoires”. Une boîte à histoire est un objet destiné aux enfants qui raconte des histoires préenregistrées adaptées pour le développement de l’enfant. Il existe toutes sortes de boîtes à histoires sur le marché, l’objectif du projet est de concevoir de A à Z une boîte à histoire à prix équivalent de ce qui existe sur le marché. En plus, nous devions trouver un moyen d’ajouter facilement des histoires avec un câble USB.

Durant les 100 heures de projets, nous avons découvert le monde de l’électronique, nous avons pu faire de la soudure, de la programmation, de la recherche d’information sur des composants, une prise en main de logiciels comme EAGLE, de la conception CAO…

Déroulement du projet

Le projet s’est déroulé en plusieurs étapes pour arriver à la construction finale de la boîte à histoire. La première est la recherche des composants dont nous avions besoin pour faire fonctionner la boîte et la découverte de l’Arduino.

1) Recherche des composants de la boite et la découverte de l’Arduino

Tout d’abord, comme nous partions de zéro, il fallait faire des recherches sur les composants qui nous seraient utiles pour la conception de la boite à histoire. Pour commencer, nous avons fait des recherches et testé des shields que nous avions déjà à l’école. Ensuite, nous avons commandé le matériel qui nous manquait pour construire la boite à histoire. Nous avons testé tout les shields séparément avant de les combiner ensemble.

C’était assez fastidieux car nous ne savions même pas si c’était possible de fabriquer une boîte à histoire avec Arduino.

Au départ, nous avons essayé un écran de 128*128 pixel. Il allait servir d’écran d’information pour la sélection des histoires. Nous avons réussi à créer une interface correcte pour l’Arduino. Nous lui avons aussi créé un logo pause pour qu’il change en fonction d’un bouton.

Ensuite, nous sommes passés sur la programmation du son. Nous avons testé au départ un shield “Music Maker” qui contenait une carte SD. Le son marchait bien, cependant nous n’avons trouvé aucun moyen d’accéder à la carte par USB. Cela nous a obligé à changer des composants et d’utiliser un DFplayer, un module mp3 pour Arduino. Ce qui nous intéressait dans le DFplayer était sa connexion USB+ et USB-. Cela nous a permis d’accéder facilement à la carte SD sans l’enlever.

Après nous avons enchainé par à la programmation des boutons. Nous avions besoin de 5 boutons :

un bouton avancer et un bouton reculer, ils servent à changer de musique. Le numéro de la musique sera modifié après l’appui sur un des 2 boutons.

un bouton pause, un appui met la musique en pause et l’écran change son affichage. Un second appui relance la musique et change l’interface de l’écran.

un bouton qui augmente le son et un qui le baisse, ces deux boutons sont tous les 2 responsables du volume. Nous aurions pu utiliser un seul bouton rotatif.

Une fois cette étape de test terminée, nous avons combiné tous les programmes ensemble pour en former un seul (dont on vous épargnera le contenu) . Nous avons utilisé un breadboard pour placer les boutons et le DFplayer. La connexion USB pour modifier les fichiers à l’intérieur de la carte SIM du DFplayer était faite grâce à une câble USB dénudé. C’est à ce moment-là que nous avons pu voir si le projet était faisable sur Arduino. Étonnement, la connexion par USB fonctionnait, et les boutons aussi.

Cable USB dénudé : câble vert= Data+ , câble blanc= Data –

2) Impression du shield Arduino

La première étape était terminée, la seconde était de transformer l’amas de fils présent sur le breadboard en une carte électronique. Nous avons utilisé le logiciel EAGLE pour créer la carte sur mesure.

Pour imprimer la carte, il faut tout d’abord importer les composants et faire leurs liaisons sur la partie “shematic” d’EAGLE. C’est assez long car il faut retrouver la référence de chaque composant que l’on veut ajouter

Une fois la partie “shématic” faite, nous passons à la partie “ bord” du logiciel. Cette partie a pour objectif de reproduire les mêmes liaisons entre les composants que celles présente lors de l’impression. Nous ne pouvons pas croiser les fils de la carte contrairement à la partie “shématic”.

Nous avons eu besoin de faire 2 prototypes pour que la carte marche entièrement. Avec cette carte, nous avons aussi imprimé une petite carte qui servira d’entrée USB. Le VCC, le GND, le USB+ et USB- seront récupérés par des borniers à vis au bout de la petite carte.

3) La batterie

La dernière étape pour avoir un objet fonctionnel était l’ajout de la batterie. La boîte à histoire doit être transportable, il nous faut donc une batterie rechargeable pour assurer son fonctionnement. Nous avons utilisé un shield arduino batterie ainsi qu’une batterie de 3.7 volt et de 1.2 Ampères. La batterie est rechargée par un connecteur micro USB.

3) CAO

Nous avons ensuite fabriqué un boîtier pour la boîte à histoire. Il nous restait peu de temps pour faire un design stylisé, nous avons donc fait un design très simple. Le boutons présent sur le shield imprimé sont superposés par des surboutons.

Conclusion

Nous avons apprécié faire ce projet, c’était très enrichissant. Nous avons découvert l’univers de l’électronique à notre façon. Cette période de projet était très intéressante pour nous. Être en autonomie nous a appris à nous débrouiller et à apprendre à notre rythme. Nous avons pu progresser par nos propres expériences, ce qui est encore plus gratifiant. De plus, ce projet a joué un rôle important pour notre avenir. Nous voulons tous les 2 travailler dans un milieu proche de l’électronique ou de l’informatique.

Nous sommes satisfait de notre travail, la boite est fonctionnelle. Il reste toujours beaucoup d’éléments à perfectionner. Avec plus de temps, nous aurions pu par exemple ajouter un mode veille ou créer un meilleur visuel. Pour plus d’information, lien vers le GitLab Angers.

En partant de la droite, Adrien et Maxime

Merci d’avoir lu jusqu’au bout !

Adrien Morille et Maxime Lambert

Projet PEIP 2A – Robot 5R

Publié le 24 mai 2023 par Meline Tarleve

La PlotClock

Bonjour à tous !

L’objectif de ce projet est de réaliser une Plotclock où le robot a pour tâche d’écrire l’heure en temps réel. Ce robot fonctionne avec deux bras, composés tous les deux de deux avant-bras, reliés entre eux au niveau de la tête d’écriture. Les deux bras sont dirigés de manière à dessiner l’heure sur l’écran à l’aide de servomoteurs.

Notre robot est équipé, en tête d’écriture, d’une LED UV pour écrire l’heure sur l’écran phosphorescent. Après que le robot est affiché l’heure grâce à la LED UV, elle s’efface toute seule, avec le temps.

Voici quelques étapes de la conception de notre robot en passant par la CAO, la programmation, l’électronique et bien sûr quelques problèmes rencontrés.

Notre projet a débuté par une phase de recherche

Avant de nous lancer dans la conception de notre robot, nous avons cherché à comprendre comment un robot 5R fonctionne. Pour cela, nous avons fait de nombreuses recherches sur la cinématique inverse, les angles que les servomoteurs doivent réaliser afin que la tête d’impression aille aux coordonnées cartésiennes que nous souhaitons. Pour cela nous avons fait des simulations avec les servomoteurs sur TinkerCAD pour comprendre comment manipuler les servomoteurs et comment fixer les angles afin de pouvoir maîtriser les mouvements des bras.

Simulation des servomoteurs avec potentiomètres à l’aide du logiciel TinkerCAD

Après ces essais et de nombreux schémas, nous sommes parvenus à établir trois fonctions qui seront utiles pour déplacer les bras aux coordonnées souhaitées :

//consine formula function
double cosineRule(double a, double b, double c) {
    return acos((sq(a)+sq(c)-sq(b))/(2*a*c));
}

//distance computation macro 
#define dist(x,y) sqrt(sq(x)+sq(y))

//atan2 formula macro 
#define angle(x,y) atan2(y,x)

Conception de notre robot sur SolidWorks

La deuxième étape est de concevoir notre robot sur Solidworks. Nous avons modélisé les bras, les avant-bras, le socle et son couvercle. Le socle, le robot en lui-même, contient les servomoteurs ainsi que le ruban phosphorescent qui a été placé dessus. Lors de la modélisation des bras, nous avons fait face à un problème majeur. En effet, lors de la première impression, les bras et les avant-bras étaient de la même taille, en plus d’être trop long. En faisant des essais avec les servomoteurs, nous nous sommes rendus compte qu’à cause de leur taille, les bras allaient trop facilement dans leur position limite. C’est-à-dire comme le montre l’image suivante :

Voici quelques vues de nos bras, de notre socle et enfin de l’assembage de notre robot avant l’impression, après avoir rectifier le problème rencontré :

Ce bras ci-dessus (bras 2) est un peu plus épais que les autres afin qu’on puisse garder la tête d’écriture parfaitement parallèle par rapport à l’écran de ruban.

Modélisation du bras 4 (avec la tête d’écriture)

Vidéo de l’impression 3D des bras du robot

Vidéo de l’impression 3D du socle de notre robot

Après avoir modélisé chaque pièce une par une, nous les avons assemblées afin de mieux visualiser notre robot final.

Assemblage & programmation de notre robot

Ensuite, une fois l’impression terminée, les bras réimprimés plus petits, nous avons assemblé chaque composant entre eux, collé le ruban adhésif phosphorescent sur le robot, fixé les bras sur les servomoteurs. Après avoir reçu tous nos composants dont le module horloge afin d’écrire l’heure correctement, nous avons soudés et connectés les câbles sur la carte Arduino.

Voici une image de notre robot avec tous les câbles assemblés. Sur l’image de droite, vous pouvez voir un schéma de l’assemblage sur TinkerCad afin de mieux visualiser les branchements de chaque composant.

À partir de ce moment-là, nous devions essayer le programme que nous avions développé en même temps que la modélisation et l’impression. Lors du lancement de notre programme, le robot affichait l’heure mais à l’envers c’est-à-dire en mode miroir (comme vous pouvez le voir sur la vidéo ci-contre). Nous avions donc un problème avec notre repère des coordonnées. En effet, en faisant de multiples tests, nous avons compris que le sens de l’axe des x était inversé.

Après avoir identifié le problème, nous devions le corriger dans notre programme, inverser le sens des chiffres, mais aussi inverser le sens de l’écriture. Nous avons donc modifié les coordonnées de chaque chiffre et nous avons repensé leur position sur l’écran d’écriture. Dû au fait d’une calibration non parfaite, des petits réglages ont été effectués pour que les chiffres soient droits. Prenons l’exemple du chiffre 2 :

Avant l’ajustement :

 case 2: 
            digitStart(0,3/4);
            digitArc(1/2,3/4, 1/2,1/4, 1/2, -1/8);
            digitArc(1,0, 1,1/2, 3/8, 1/2);
            digitMove(1,0);
            break;

Après l’ajustement

case 2: 
            digitStart(1,3/4);
            digitArc(1/2,3/4, -1/2,1/4, 1/2, -1/8);
            digitArc(0,0, -1, 1/2, 3/8, 1/2);
            digitMove(0,1/4);
            break;

Pour finir, pour que notre robot soit autonome, nous avons ajouté une batterie. De plus, nous voulions mettre un interrupteur afin qu’on puisse éteindre l’alimentation de notre carte Arduino pour que la batterie dure plus longtemps. Nous nous sommes vites rendus compte que notre module horloge devait être alimenté en continue pour qu’il écrive l’heure en temps réel. Notre projet de mettre un interrupteur n’était donc pas possible avec ce module horloge. Il existe d’autres modules horloge qui possèdent une pile intégrée afin qu’ils restent constamment alimenter pour qu’ils ne perdent pas l’heure. Nous avons donc décidé de mettre des piles rechargeables 6V de 1600mA pour éviter qu’elles ne se déchargent trop vite.

Bilan & Critiques

Ce projet a été très enrichissant et intéressant. Nous avons pu mettre à profit de nombreuses compétences notamment en conception mais aussi en électronique, en électricité et en programmation. La partie la plus dure a été la programmation avec un langage qui était nouveau pour nous.

De plus, nous avons appris à être autonome et prendre des décisions dans un projet de A à Z. Savoir se débrouiller face à différents problèmes et ne pas abandonner sont aussi deux points importants dans un projet. De plus, le travail d’équipe est une compétence essentielle pour le bon déroulement d’un projet. Nous avons donc dû savoir s’écouter entre coéquipier, exprimer chacun ses idées. Nous n’étions pas forcément toujours d’accord sur certaines choses mais en discutant ensemble, nous trouvions toujours un compromis.

Notre robot n’est qu’un prototype, il y a donc certaines choses à améliorer comme l’alimentation de la carte Arduino ou bien le module horloge. De plus, nous pourrions développer davantage notre programme pour qu’il est différente fonctionnalité comme écrire la date ou dessiner quelque chose demandée par l’utilisateur. Pour aller plus loin, développer une application pour le diriger depuis son portable pourrait être intéressant afin d’avoir de multiples fonctionnalités.

Nous tenons à remercier notre référent, M. LAGRANGE, pour nous avoir aider et guider tout au long de ce projet.

Merci pour votre lecture !!!

Mohamad DEIRI / Méline TARLEVE

Amélioration de la machine de recyclage de matériaux pour impression 3D

Publié le 18 juin 2021 par FOUGERAY Alan

Bonjour à toutes et à tous !

Nous sommes deux étudiants en deuxième année de cycle préparatoire d’école d’ingénieur, Alan et Romane. Nous avions pour projet d’améliorer la machine de recyclage de matériaux pour impression 3D.

Contexte

La machine de recyclage de matériaux pour impression 3D existait déjà au début de notre projet. En effet, il y a trois ans, deux élèves espagnols se sont lancés dans la création de cette machine composée de plusieurs éléments :

l’extrudeuse : permettant de chauffer les granulés et de faire sortir du fil
le système de refroidissement : constitué d’un ventilateur qui refroidit le fil dès sa sortie
le système de tirage : tire sur le fil
le système de bobinage : permettant d’obtenir une bobine de fil pour tout types d’imprimante 3D
le système d’alimentation : permettant de mettre en fonctionnement les deux moteurs
le système de mesure : permettant de mesurer le diamètre du fil instantanément

Photo de la machine de recyclage de matériaux pour impression 3D

Objectifs :

Nous avions pour objectif de vérifier le fonctionnement de la machine et de faire les réparations nécessaires dans un premier temps. Ensuite nous devions refaire le support du capteur pour avoir une meilleure précision sur les valeurs affichées. Pour finir, nous devions faire des modifications sur le code de la carte Arduino Uno afin d’obtenir un affichage plus précis et lisible.

Réparations :

La machine n’ayant pas fonctionné pendant trois ans, nous avons dû faire quelques réparations dès la première mise en route. Nous avons branché plusieurs fils ainsi que fait quelques raccordements. Nous devions coller différentes pièces qui s’étaient désolidarisées avec le temps ou encore serrer des vis. Nous avons donc dû faire attention à chaque élément de la machine dès la mise en route pour ne pas passer à côté d’une modifications ou réparations à faire.

Support Capteur :

Nous nous sommes documentés sur les différentes formes que peut avoir un support capteur. Nous sommes tombés sur le site suivant :

Nous avons décidé de réaliser notre support de capteur en trois parties :

4 pieds
pièce du dessous avec la place du capteur
pièce du dessus avec la place de la LED rouge

Ensemble des pièces qui constituent notre support Capteur

Après plusieurs impressions et réglages nous avons obtenu le support de Capteur que nous voulions.

Photo du support de Capteur final

Carte Arduino Uno :

Nous avons fini notre projet en nous occupant de la carte Arduino Uno. Notre but était d’afficher la valeur du diamètre mesuré de façon plus claire. Pour cela nous avons étudié le code de la carte Arduino Uno. Après plusieurs recherches sur le site internet Arduino et à partir de vidéos, nous avons trouvé le problème. Il fallait enlever cette ligne du code pour que l’affichage soit directement plus clair :

Conclusion :

Pour conclure nous avons réussi à refaire fonctionner cette machine de recyclage de matériaux pour impression 3D ainsi qu’à l’améliorer grâce au nouveau support de capteur et une modification du code existant afin d’obtenir un affichage du diamètre plus clair et lisible.

Compteur binaire motorisé

Publié le 18 juin 2021 par BLAIN Thomas

Salut les polypotes !

Nous sommes Maëlys DUBOIS et Thomas BLAIN, étudiants en deuxième année de cycle préparatoire intégré à Polytech Angers. Pour notre quatrième semestre, nous sommes amenés à mettre en œuvre un projet, de A à Z. Notre objectif est de concevoir puis construire une maquette de démonstration (salons, forum, etc.) d’un compteur binaire motorisé, que l’on pourra facilement déplacer. Nous avons choisi ce projet car il nécessite des compétences en mécanique/conception et en informatique/électronique, domaines sur lesquels nous sommes complémentaires.

I. Présentation du projet

Vous pouvez voir ci-dessous le principe du système :

Valeur 0 en binaire

Valeur 1 en binaire

Valeur 2 en binaire

Notre compteur comporte de nombreuses pièces, dont une partie imprimée en 3D, d’autres sont en dibond (plaque plastique entourée de plaques d’aluminium), et d’autres sont en bois.
Notre objectif avec ce système est de pouvoir retranscrire au grand public le principe du langage binaire, tout en pouvant manipuler un système facile d’utilisation.
Le principe de base est que vous choisissiez un nombre quelconque pour que le compteur vous affiche son équivalent en binaire.
Vous pouvez expérimenter 3 modes de fonctionnement différents et indépendants parmi les suivants :
– Incrémenter un à un grâce à un bouton poussoir. (incrémenter = +1)
– Incrémenter en continu grâce à un bouton poussoir.
– Choix du nombre à afficher (entre 0 et 255) en sélectionnant le chiffre souhaité avec un encodeur rotatif (avec bouton) qui commande un afficheur.

II. Travail réalisé

Nous nous sommes par la suite lancés dans le dimensionnement des pièces pour que l’ensemble puisse rentrer dans notre valise et dans les essais de composants électroniques dont nous pourrions avoir besoin.
Après avoir dimensionné les pièces sur le logiciel FUSION 360, nous nous sommes rendu compte que certaines pièces ne pouvaient pas être imprimés en 3D, étant donné leur taille trop importante.

Modélisation plaquette numérotée sur Fusion360.

La partie électronique du système est dirigée par une carte de commande Arduino UNO. Nous avons pu tester et configurer les fonctionnalités de comptage sur les afficheurs après avoir appris à utiliser le langage Arduino et son logiciel. Nous avons commencé à tester et programmer indépendamment chaque élément électronique dont nous pourrions avoir besoin pour ensuite commencer à les lier ensemble ou améliorer leur fonctionnement.

Système électronique sous le fond de commande.

Système électronique “partie commande”.

Nous sommes passés par des phases de recherche de composants que nous ne pouvons pas forcément concevoir en impression 3D.
Nous avons recherché quel moteur pas à pas serait le plus à même de convenir à notre système, quelles rondelles utiliser pour séparer les plaquettes, quelles charnières utiliser pour basculer notre compteur, quel système poulie-courroie utiliser pour la transmission.

Notre moteur “pas à pas” et son système de transmission “poulies-courroie”.

Étant donné que nous nous sommes rendu compte lorsque nous voulions faire l’impression 3D de nos fonds et de nos potences que ce n’était pas possible pour celles-ci, nous avons opté pour des plaques de dibond pour les fond ainsi que du bois pour les pieds servant à soutenir nos fonds et les blocs de maintien des potences

Pour finir, nous avons enfin pu procéder à l’assemblage de notre compteur binaire et le relier à son système de commande.

III. problèmes rencontrés

Ensuite, nous avons voulu commencer l’impression test de nos pièces en 3D mais nous avons attendu 2 mois sans que cela ne puisse être possible. Les files d’attente étaient très longues et toutes les imprimantes 3D étaient HS. Jusqu’à la fin de notre projet, nous n’avons donc jamais pu imprimer nos pièces. De ce fait, nous avons dû chercher à contacter une connaissance possédant une imprimante 3D et qui pourrait nous aider pour la conception de nos pièces finales.

Concernant la partie électronique, c’est notre manque de connaissance qui nous a causé le plus de tort. Nous sommes donc assez limités lorsque des problèmes surviennent. Lorsque les programmes ne fonctionnent pas comme nous l’attendions, cela peut nous prendre beaucoup de temps afin de résoudre le problème.
Ensuite, nous avons eu quelques soucis avec le logiciel Arduino. Nous avions un problème de bibliothèque, qui ne fonctionnait pas sous linux. Il a donc fallu passer sous Windows, mais ça n’a pas fonctionné dès le début. C’est en passant sur le logiciel Arduino en ligne que notre programme a pu fonctionner normalement.
Il a aussi fallu adapter, tout au long du projet, les options du compteur au fur et à mesure des essais des composants. Il y avait des composants auxquels nous n’avions pas pensé au préalable, d’autres qui étaient finalement trop compliqués à utiliser, etc.

IV. Conclusion

Voici donc le résultat de notre compteur binaire :

Position “utilisation du système”

Position “repos/transport”

Vous pouvez consulter notre compte rendu qui vous expliquera plus en détail le déroulé du projet ici :

Merci de votre attention !

Maëlys et Thomas, PeiP 2A, Polytech Angers

Le banc d’essai à trombone

Publié le 18 juin 2021 par RIVAULT Mathieu

Bonjour à toutes et à tous, nous sommes deux étudiants, Reyan et Mathieu en deuxième année d’école d’ingénieur à Polytech Angers. Sur ce blog vous allez trouver un avant-gout du projet que nous avons réalisé. Avant de commencer il faut savoir qu’un banc d’essai sert à éprouver physiquement un objet jusqu’à ce qu’il se casse afin d’effectuer des tests de fiabilité. L’objectif de notre projet était donc de créer un système pouvant remplir ce rôle afin d’étudier la fiabilité d’un trombone grâce aux résultats obtenues. Cette maquette aura pour but d’être utilisée lors de conférence ou de cours afin d’illustrer avec une démonstration concrète les essais de fiabilité.

Maquette expérimentale laissée par un professeur au début du projet

Par conséquent pour des raisons pratiques nous avons décidé de la fabriquer dans un format facile à transporter

Cette maquette devait être autonome. C’est-à-dire qu’elle devait exercer une force sur le trombone jusqu’à ce qu’il se casse. Une fois cassée la maquette devait s’arrêter et nous donner le nombre de cycles effectués avant cette casse. Notre projet comporte donc une partie importante d’automatisation, qui est principalement géré par une carte Arduino Uno que nous avons entièrement codé et une partie CAO où nous avons créé notre maquette de A à Z.

Face avant de notre maquette sur SolidWorks

Exemple de pièce SolidWorks

Une fois la CAO terminée nous devions usiner nos pièces. Pour cela nous avons utilisé le Charly Robot à notre disposition au FabLab, voici une vidéo de la machine en action :

Suite à l’usinage des pièces nous avons dû assembler notre maquette. Cependant quelques péripéties apparurent en cours de route comme le vissage du bois qui fut impossible (nous avons donc dû procéder à du collage) ainsi que l’assemblage de la partie mobile de l’étau.

Maquette réalisée

Malheureusement, nous devons encore effectuer quelques modifications avant que notre maquette soit fonctionnelle. J’espère que cette présentation de projet vous aura donné envie d’en savoir plus et que vous ferez partie du prochain groupe ayant pour mission de finaliser ce projet.
Merci d’avoir pris le temps de lire notre article. Nous vous laissons avec notre maquette finale en action.

Rasoli Reyan
Rivault Mathieu

Maquette d’une maison connectée

Publié le 17 juin 2021 par GUERFI Amir

Bonjour à toutes et à tous,

Nous sommes Amir GUERFI, Walid JALALI, Jonas CHERON et Valentin HUREL, quatre étudiants en deuxième année de cycle préparatoire du parcours des écoles d’ingénieurs Polytech. Nous avons pris énormément de plaisir à réaliser le projet de création d’une maquette de maison connectée, supervisé par notre professeur, Monsieur Riahi.

Présentation du projet :

Modèle de maison sur Revit

L’objectif de ce projet est de réaliser une maquette à échelle réduite d’une maison individuelle équipée d’un enregistreur autonome de données (température, humidité, taux de CO2, …). Ces dernières peuvent être exploitées par la suite pour l’étude et la modélisation du comportement des occupants de la maison. Cette solution peut être facilement déployée sur un bâtiment à échelle réelle.

De ce fait, la réalisation de ce dernier s’est déroulée en trois parties distinctes :

La première partie consistait à la conception de la maison. Nous avons de ce fait, à l’aide d’un logiciel de CAO, imaginé et dessiné une maison à l’échelle réelle avec une porte et deux fenêtres comme le stipulait le cahier des charges. Une fois les plans réalisés, nous avons tous ensemble décidé de l’échelle adoptée pour la réalisation d’une maquette de cette maison. Il fallait donc trouver le juste milieu entre une maquette assez grande pour pouvoir travailler aisément dessus et une maquette de taille raisonnable afin de limiter les coûts de fabrication et de faciliter le stockage de cette dernière. Nous avons donc décidé de retenir l’échelle 1/20ème afin de satisfaire ces contraintes.

La deuxième étape de ce projet était d’apprendre à manipuler une carte Arduino et les différents capteurs imposés par le cahier des charges. Ces derniers étaient composés de capteurs de température, d’humidité, de CO2, de luminosité et d’ouverture/fermeture de fenêtres. Il fallait donc programmer et relier tous ces capteurs avec la carte Arduino à l’aide de codages complexes afin d’enregistrer les différentes données de la maison et de les afficher dans un tableau Excel.

Enfin, le projet s’est terminé par la réalisation concrète de la maquette avant d’y intégrer tous les capteurs et de réaliser les différentes mesures.

Travail Réalisé :

La première contrainte de cette modélisation était de penser à construire une maison dont la réalisation en maquette réelle à échelle réduite ne poserait pas trop de problème.
Afin d’avoir des composants à nos dimensions et un design voulu, nous avons modélisé ces fenêtres, volets et porte avant de les importer dans notre maison. Pour finir, nous avons ajouté des textures aux murs, sol et toit de notre maison afin de la rendre plus réelle et design.

Ensuite nous avons commencé la partie « programmation » des différents capteurs. En effet, l’objectif premier de notre étude est de recueillir les données de notre maquette. Nous avons pour cela utiliser une carte Arduino Uno R3 qui nous a permis de recueillir les mesures sur un tableur Excel. Cependant, afin de mieux comprendre leur fonctionnement, nous avons traité chaque capteur séparément, avant de les rassembler.

Carte Arduino Uno R3

Ainsi, nous avons débuté par le capteur de luminosité. Nous avons fait le choix d’une photorésistance GL5528. Ce capteur est composé d’une résistance dont la résistivité varie en fonction de l’intensité lumineuse. Ainsi, la résistance du capteur diminue lorsque l’intensité lumineuse de l’environnement augmente. Nous obtenons en sortie une tension électrique que nous convertissons ensuite en luxmètre par le biais de la formule :

Avec U = 5 volts, la tension délivrée par l’Arduino.
Analog est la valeur analogique en sortie de la photorésistance.
1024 est le nombre de valeurs possibles. L’Arduino code sa tension aux bornes du port analogique (0V à 5V) sur 10 bits, soit 2^10 = 1024.
Et donc V en volts.

Avec R_0 = 10 000 ohms et R en ohm.

L en lux.

Pour le montage de capteur, il était impératif d’ajouter une résistance en série de 10 000 Ω. Nous recueillons la valeur de la tension en sortie sur le pin analogique A0, capable de lire la valeur d’une tension renvoyée par notre capteur.

Photoresistance GL5528

Ensuite, nous nous sommes attaqués au capteur d’ouverture fermeture de référence ADA375. Celui-ci se compose de plusieurs fils, on relie le premier sur la GND de l’Arduino et le second sur le pin DIGITAL n°4. Lorsque les deux parties sont en contact, le capteur laisse passer le courant (circuit fermé) et renvoie 0. A l’inverse, lorsque que l’on les éloigne l’une de l’autre, le courant ne circule plus (circuit ouvert), ainsi le capteur renvoie 1.

Capteur d’ouverture fermeture ADA375

En outre, nous avons traité le capteur de température et d’humidité : AM2302 (version filaire de la DHT22). Ce capteur est composé d’un capteur d’humidité capacitif et d’une thermistance qui mesurent l’humidité et la température de l’air ambiant. L’AM2302 est connecté au pin 5V, au pin GND et renvoie un signal numérique sur le pin de sortie digital n°2.

Capteur de température et d’humidité AM2302

Plus tard dans le projet, nous avons fait l’acquisition du capteur d’environnement et de CO2 de référence CCS811. Il s’agit d’un capteur environnemental qui nous permettra de connaître la présence de COV dans notre maquette et d’en déduire le niveau de composés organiques volatils totaux (TVOC en anglais). Il permet également de déterminer le taux de CO2 équivalent présent dans l’air.

Capteur d’environnement CCS811

Voici donc une représentation graphique du montage des capteurs sur l’Arduino :

Représentation du montage des capteurs sur l’Arduino

Vous pourrez aussi visualiser le code du programme de notre Arduino via ce lien :
https://create.arduino.cc/editor/amir49/53ccc0f1-98a0-45bf-ab38-cf373de0ea6f/preview

Enfin, pour réaliser notre maquette, la première opération consistait à déterminer les dimensions et l’échelle de cette maquette. Nous avons pris comme référence le fait que nous voulions que notre maquette fasse 50 cm de long. La longueur réelle de notre maison étant de 10 m, notre maquette est donc une reproduction de notre maison à l’échelle 1/20. Nous avons donc poursuivi en convertissant toutes les côtes de notre maison grâce à l’échelle calculée. Ensuite, nous avons préparé des plans de découpe pour chaque pièce composant notre maquette.

Pour assembler ces pièces, nous avons opté pour de la colle à bois ainsi que des équerres pour le toit.

Pour nos ouvertures, nous avons découpé des planches de plexiglas pour les fenêtres et de contre-plaqué pour la porte. Puis, nous les avons fixés aux murs de notre maison à échelle réduite avec des charnières. A l’extérieur, nous avons ajouté des volets coulissants sur rails. Enfin, nous avons fixé les différents capteurs, aux fenêtres et au sol de la maison. Nous avons également fixé la carte Arduino à l’intérieur de la maison et passé un câble afin de relier la carte Arduino à un ordinateur.

Plan du mur de la façade avant de la maison

Notre maquette ce présente donc ainsi :

Maquette maison

Problèmes rencontrés :

Lors de la réalisation de la maquette, nous nous sommes rendu compte que certaines formes géométriques dessinées en CAO étaient relativement complexes à réaliser dans la réalité.
Pendant cette opération, nous avons été surpris par la difficulté à réaliser des découpes droites à l’aide de la scie sauteuse.
Par la suite, nous avons été confrontés à un problème plus important. Nous ne savions pas comment réaliser les trous de fenêtres dans les panneaux de contreplaqués.
Pour finir, nous avons dû trouver une solution afin de pouvoir, si souhaité, réduire la luminosité à l’intérieur de la maison. Néanmoins, nous n’avions plus de charnières disponibles. Nous avons donc réfléchi à un autre système de volets amovibles avec le peu de matériaux restants.

Critique des résultats obtenus :

Une fois la maquette finalisée et les capteurs installés, nous avons pris le temps de relever et d’analyser les différentes données transmises par la carte Arduino sur l’ordinateur. De ce fait, nous avons pu observer que les capteurs d’ouverture et de fermeture des fenêtres étaient fonctionnels. En effet, les capteurs transmettent une certaine valeur lorsque les fenêtres étaient fermées et une autre valeur lorsqu’elles étaient ouvertes.
Aussi, lorsque les volets étaient fermés, le capteur de luminosité envoyait une valeur beaucoup plus faible que lorsque les volets étaient ouverts.
Nous avons également obtenu des valeurs cohérentes de la part du capteur de température et d’humidité.
Enfin, dans le but d’analyser le capteur de qualité d’air, nous avons ou non souffler sur ce capteur. Nous avons ainsi remarqué des différences flagrantes au niveau des résultats en fonction des différentes conditions citées ci-dessus.

Tableau résultats

Montage Arduino dans la maquette

Conclusion

Ce projet fut pour nous très enrichissant. Nous avons pris un réel plaisir à travailler sur notre maison intelligente. Nous avons fait le choix de travailler sur cette maquette car il s’agit d’un projet concret dont la prochaine étape aurait été de l’appliquer dans une réelle pièce. De plus, nous avons été amenés à travailler sur différents aspects. En effet, dans le cadre de ce projet, il y avait de la programmation, de la CAO et la construction finale de la maquette.

RUBIBOX – Robot d’arcade Rubik’s cube

Publié le 17 juin 2021 par BENIER Lou

Présentation de notre projet :

Bonjour à tous !

Nous sommes Lou Bénier, Erwann Miloux et Maxime Toublanc, étudiants de 2ème année à Polytech Angers.

Cet article est dédié à notre projet de fin d’année porté sur le domaine de la robotique.

Nous vous présentons donc Rubibox, notre robot d’arcade de réalisation du Rubik’s cube.
Le but étant de résoudre ce célèbre casse-tête au moyen de boutons poussoirs en ajoutant comme difficulté l’incapacité de pivoter la face orange.

Le cube à résoudre est à l’intérieur d’une boîte en plexiglas transparent, rendant la manipulation manuelle impossible.

L’idée est d’intégrer ce projet à un autre bien plus grand : Escape Polytech.
En effet nous l’avons conçu dans le but qu’il soit encastré dans un bloc de l’armoire d’Escape Game pour l’édition Escape Polytech à venir.

—
Conception & Réalisation :

Nous sommes partis sur l’idée d’un cube dans un cube.

Les moteurs sont vissés sur les faces intérieures d’un cube en plexiglas, tenant le Rubik’s Cube au centre.
La pièce orange non pivotable est face à l’utilisateur du robot, sa vue n’étant pas obstruée par un sixième moteur.

Modélisation CAO de Rubibox (SolidWorks)

Pour ce qui est de la commande des moteurs, ils sont activés suite à l’appui d’un bouton d’arcade de la couleur de la face correspondante.

Ces derniers sont disposés sur un petit boîtier au-devant du cube en plexiglas.
On ajoute un bouton « mélange » (shuffle en anglais) à l’avant du boîtier.
Associés à ces boutons, des LED de même couleur s’allument lors de la rotation d’une face.
La liaison entre les boutons poussoirs et les moteurs, se fait via 3 cartes Arduino UNO.

Il nous a fallu songer à une méthode pour décider du sens de rotation (horaire ou anti-horaire).

Pour ce faire, nous utilisons un interrupteur levier ON OFF ON, qui activé à « gauche » pivote la face dans le sens anti-horaire, et activé à « droite » donne une rotation horaire.
C’est dans l’esprit du robot d’arcade, que nous voulons donner à cet interrupteur l’apparence d’un joystick d’arcade.

Au cours de ce projet nous avons dû utiliser différentes machines spécifiques telles que :

La découpe laser du fablab des Beaux-Arts pour le cube en plexiglas transparent et le boîtier que nous avons fait de la même matière par efficacité.

Découpe laser du plexiglas (Beaux-Arts)

Pièces de plexiglas à la sortie de la découpe

Afin d’encastrer les faces du cube les unes avec les autres, nous avons eu l’idée de donner aux côtés une forme de remparts. Ainsi nous avons un unique fichier SolidWorks pour les 6 faces.

L’imprimante 3D du fablab de Polytech Angers pour les petites pièces liant les 5 moteurs aux centres des faces du Rubik’s Cube, et les pièces liant les moteurs aux faces en plexiglas.

Impression 3D des pièces qui contiendront les moteurs

La perceuse du fablab de Polytech Angers effectuant des trous dans le plexiglas pour y fixer les moteurs et les équerres.

Nous perçons les trous qui serviront à visser les moteurs

—
Principe du code :

Notre code repose sur la communication de 3 cartes Arduino UNO branchées en série.

On appelle ce système un bus I2C (Inter-Integrated Circuit) composé d’une Arduino dite MASTER, et des 2 autres dites SLAVE 1 et SLAVE 2.

Le principe de ce bus est que la MASTER contient le programme principal et envoie des ordres aux SLAVE 1 et SLAVE 2. Elle peut aussi demander une « requête » à celles-ci.

Pour illustrer au mieux ce processus voici un exemple où l’on veut faire tourner une face du Rubik’s Cube pour laquelle le bouton déclencheur se situe sur la MASTER, le moteur et la LED sur la SLAVE 1, et l’interrupteur levier sur la SLAVE 2 :

Schéma explicatif du principe de communication entre les Arduino

Code Arduino correspondant au schéma précédent

Test de ce code en vidéo (moteur vert sur SLAVE 1 actionné par bouton bleu sur MASTER) :

Le choix d’utiliser 3 cartes Arduino est lié au fait d’avoir 5 moteurs. Sur chaque Arduino est placée une carte Shield ne pouvant contenir que 2 moteurs chacune.

On a alors réparti les différents composants comme suit : les 6 boutons sur la MASTER, les LED sur la SLAVE 1 où sont branchés leur moteur respectif, et l’interrupteur sur la SLAVE 2.

En voici le schéma électrique :

—
Fabrication & Assemblage :

Nous avons conçu les faces de la boîte en plexiglas dans le but de les encastrer les unes avec les autres grâce aux remparts.

Seulement, à cause du jeu existant entre elles, nous avons décidé de les fixer à l’aide d’équerres.

Pour ce qui est du joystick, nous avons préféré le fabriquer nous-même, l’imprimante 3D étant très prisée. Dans la boule de joystick taraudée, commandée au préalable, on y a inséré une vis (dont on a coupé la tête), à laquelle nous avons collé un tube métallique pour la tige. Le tout fixé sur l’interrupteur levier lui-même vissé au boîtier.

Puis nous avons dû sectionner, diviser et rallonger notre alimentation de 9V afin d’alimenter notre robot via la carte Arduino MASTER par l’embout d’alimentation DC, et les trois cartes Shield par les fils + et – qui en découlaient.

—
Rendu final :

Nous finissons notre projet en tournant deux faces sur les cinq requises.

En effet, nous avons rencontré divers problèmes que nous n’avons pas pu régler. Néanmoins, nous sommes capables de tourner ces faces en choisissant le sens de leur rotation grâce au joystick orange, ce qui est un point positif.

Pour l’assemblage final, nous avions convenu de glisser les cartes Arduino sous le boîtier des boutons, mais par manque de place elles ont été déposées dans la boîte en plexiglas.

Assemblage final de Rubibox

—
Problèmes rencontrés :

Au cours de notre projet, nous avons rencontrés plusieurs obstacles.

Pour commencer, le plus flagrant, tous les moteurs ne tournent pas. En effet, nous suspectons le fait que l’une des deux SLAVE ne puisse plus recevoir d’informations venant de la MASTER. Nous ignorons encore la raison, peut-être qu’un problème est survenu lors de l’assemblage du robot ou bien lors du soudage à l’étain des fils de branchement sur les cartes Shield.

Autre problème : nous avions commencé le projet avec un Rubik’s cube différent.

Nous avons conçu Rubibox de manière à encastrer les moteurs dans les centres du cube. Or, lors de l’assemblage, nous nous sommes rendus compte que les centres tournaient curieusement indépendamment du reste de la face. En conséquence, le moteur tournait correctement, mais la face ne suivait pas. Nous avons donc dû prendre un de nos Rubik’s cubes personnels n’ayant pas ce problème, pour mener à bien notre projet.

S’ajoute à tout ceci un problème esthétique.

En effet nous manquions de place sous le boîtier des boutons pour y insérer les cartes Arduino ce qui encombra la boîte en plexiglas dans laquelle sont déjà placés le cube et les moteurs. De plus nous voulions fabriquer un boîtier opaque pour cacher tous les fils. Malheureusement le Fablab des Beaux-Arts, lieu où nous avons utilisé la découpe laser, ne pouvait nous céder uniquement du plexiglas transparent pour toutes nos pièces.

Puis, sur ce même boîtier nous avons constaté un défaut de conception pour l’emplacement du bouton de mélange du Rubik’s cube.

Effectivement, lors de l’assemblage, il nous a été difficile d’intégrer ce bouton à cause de la forte proximité des boutons blanc et jaune. Nous aurions dû le placer à gauche, près de l’interrupteur levier, plutôt qu’à droite à l’encontre des boutons.

—
Conclusion :

Malgré les quelques complications survenues, nous ne pouvons que conclure positivement.

Nous avons mené ce projet en équipe, et sommes ravis du rendu de Rubibox même si nous sommes un peu frustrés de ne pas le voir fonctionner dans son entièreté comme prévu.
Tout au long de ce projet, nous avons été actifs et les idées fusaient.
Ce projet nous a permis d’acquérir de nouvelles compétences, d’apprendre à utiliser certaines machines, et surtout d’avoir le plaisir de mettre en pratique nos idées, notre imagination.

Voici quelques points à améliorer sur Rubibox :

Points à améliorer :

Nous avions intégré dans le code une partie calculatoire permettant de connaître la position des couleurs sur le cube à tout instant. Ainsi, lorsque le cube aurait été résolu, les LED se seraient allumées telles une guirlande.

Pour améliorer le robot, on pourrait ajouter un émmeteur de son faisant retentir une petite mélodie au même instant que la guirlande de LEDs.
Pourquoi pas aussi un petit écran LCD servant de chronomètre, indiquant le temps de résolution mis par le joueur.
De plus, dans l’idée de l’intégrer à l’armoire d’Escape Polytech, une pose de miroirs à l’arrière pourrait être intéressante.