Projet final prototypage Louly Chloé Eloïse

🎯 Définition du projet

Nom du projet : Pingroue - Peluche mobile crochetée sur robot télécommandé

Objectif : Créer une plateforme robotique télécommandée sur laquelle on pose un animal crocheté à la main, comme une mascotte mobile. L’idée est de donner vie aux créations en crochet en les posant sur une base motorisée que l'on peut diriger à distance.

Diapo de présentation du projet :  Pingroue - Presentation

---

👥 Besoin & utilisateurs

Utilisateurs visés :

• Créateurs et créatrices de crochet

• Enfants (objet ludique)

• Grand public (objets décoratifs vivants)

• Ateliers pédagogiques autour de l’électronique + artisanat

Besoins identifiés :

• Mettre en mouvement une peluche crochetée sans câblage visible

• Base discrète et mobile

• Plateforme réutilisable avec différents personnages

---

⚙️ Fonctionnalités

Fonction principale

• Plateforme roulante contrôlée par un code arduino 

Fonctionnalités secondaires

• Rembourrage de l'animal crocheté par impression 3D (dôme)

• Plateforme stable pour fixation de l'animal en crochet par découpe laser (capôt qui recouvre l'arduino)
  

• Logo (louly.gurumi + Fablab) gravés par découpe laser

• Siège et volant pour décorer la voiture

---

🔍 Veille & inspirations

• Châssis Magician DG007 utilisé dans l’enseignement Arduino

• Projets similaires de robots décorés (sumo bots, robots mascottes)

• Personnalisation (dôme, texture, couleur, taille)

---

📄 Lean Canvas

---

🧰 Choix techniques

---

📅 Gestion de projet

MVP (Minimum Viable Product)

• Robot motorisé pilotable à distance

• Dôme supportant un animal crocheté

Planning

Nous avons commencé le projet par plusieurs sessions de brainstorming pour mettre en commun nos idées et nos centres d’intérêt. C’est à ce moment-là que Louly nous a rappelé que son passe temps favoris est le crochet. Elle fabrique des animaux crochetés qu'elle propose à la vente. L'idée de notre projet est donc née : une voiture robotisée supportant une peluche crochetée by louly.gurumi !

Le projet a été validé par notre enseignant le lundi 31 mars. Ce même jour, nous avons directement commencé à concevoir le design du robot et de sa structure. Nous avons fait des croquis à la main, imaginé la forme du capot, le support pour la peluche, et commencé le montage du châssis. En parallèle, nous avons démarré la programmation sur Arduino.

Ensuite (toujours le 31 mars) nous avons modélisé un premier dôme sur Tinkercad et l’avons exporté vers IdeaMaker pour l’impression 3D. En même temps, nous avons aussi conçu la première version du capot sur Inkscape, que nous avons testée en découpe laser.

Le mardi 1er avril, nous sommes allés au FabLab pour récupérer l’impression 3D du dôme. Puis Louly a commencé à créer l’animal crocheté autour du dôme, en respectant ses dimensions. Ce même jour, nous avons poursuivi la modélisation 3D pour ajouter des éléments comme un volant et un petit siège pour rendre le support plus vivant.

Le mercredi 2 avril, nous avons fait une deuxième découpe laser du capot, après avoir revu sa forme pour l’adapter aux dimensions de la planche avec l'arduino posé sur le dessus. Nous avons aussi extrait les fichiers du siège et du volant depuis Tinkercad vers IdeaMaker pour les imprimer.

Le jeudi 3 avril, nous avons assemblé toutes les pièces : le capot, le pingouin avec le dôme. Puis, nous avons fait les premiers tests complets du prototype. Nous avons ensuite lancé l'impression du siège et du dôme mais n'avons pas pu la terminer.

Finalement, le 28 avril, nous avons ajusté nos différents éléments comme suit : 

• Impression 3D : n'ayant pas terminé l'impression le 3 avril, nous l'avons relancée le 28. Nous avons ensuite récupéré les pièces et les avons attachée à notre capot.
• Découpe laser : Nous avons dû redécouper notre capot en augmentant la longueur. En effet, lors de nos premiers tests, le capot était trop petit et touchait donc les roues, ce qui modifiait leur trajectoire. Nous avons donc augmenté les dimensions du rectangle de base de 0,5cm.
• Code arduino : Lors de nos premiers tests, nous avons réussi à contrôler les moteurs pour faire avancer le châssis tout droit, à l'endroit et à l'envers. Néanmoins, nous voulions une trajectoire plus évoluée, nous avons donc décidé de faire faire à la voiture un carré, à l'endroit et à l'envers. (Cf code ci-dessous)

Enfin, nous nous sommes consacrées à la finalisation de la documentation et à la prise de photos pour illustrer le rendu final sur le wiki.

---

✏️ Design initial

Image du prototype générée par ChatGPT

---

🧾 Matériel utilisé

---

💻 Électronique

La partie électronique s'est décomposée en 3 parties :

1. montage du châssis

2. câblage de l'Arduino, du shield & des moteurs

3. contrôle des moteurs & de leur trajectoire via un code Arduino

Voici le détail de chaque partie : 

1. Montage du châssis

Le montage du châssis DG007 a été la première étape de notre projet. Pour le construire, il nous a suffit de suivre la notice fournie dans le kit, ainsi qu'un tutoriel youtube (cf sources).

Nous n'avons pas eu de difficultés particulières pour la construction, hormis la fixation des moteurs des roues (nous avons dû enlever une vis de part et d'autre car la deuxième ne passait pas).

2. Câblage de l'Arduino, du shield & des moteurs

Concernant le câblage de l'Arduino et du shield, il nous a suffit de les emboiter l'un à l'autre. 

Le câblage des moteurs n'a pas été compliqué non plus, nous avons simplement suivi le tutoriel du wiki DFRobot (cf sources). La seule particularité a été de vérifier le sens des branchements afin que les roues tournent toutes les deux dans le même sens.

À tout cela, nous avons ajouté la batterie, rattachée au shield (et non pas à l'Arduino !!). En effet, nous pensions que le fait d'avoir emboîté le shield et l'Arduino suffirait à les lier mais ce n'était pas le cas !! Nous avons mis du temps à comprendre que le lien entre l'Arduino et le shield n'était pas automatique !

Pour nous débloquer, nous nous sommes aidées de ChatGPT (néanmoins, non n'avons pas pu mettre la discussion en source car nous avions généré des images dans cette discussion et la fonctionnalité de partage n'est malheureusement pas disponible dans ce cas-là)

Ce que nous aurions aimé savoir :
La connexion entre le shield et l'Arduino n'est pas forcément faite. Bien penser à ajouter cette connexion si elle n'est pas induite !

3. Contrôle des moteurs & de leur trajectoire via un code Arduino

Concernant le contrôle des moteurs, nous nous sommes basées sur le code du wiki DFRobot que nous avons modifié afin d'avoir une trajectoire plus compliquée.

Voici donc la version finale du code, afin que la trajectoire de la voiture soit un carré. La voiture fait un carré en avançant puis en reculant.

Ce que nous aurions aimé savoir :
Il est important de comprendre que pour créer des angles dans la trajectoire, il faut diminuer la vitesse d'une des deux roues.

// Définition des broches de contrôle des moteurs
const int E1 = 3; ///< Vitesse du moteur 1
const int E2 = 11; ///< Vitesse du moteur 2

const int M1 = 4; ///< Direction du moteur 1
const int M2 = 12; ///< Direction du moteur 2

// Fonction pour avancer le moteur 1
void M1_advance(char Speed) {
  digitalWrite(M1, LOW);  // Le moteur 1 avance en utilisant la broche M1
  analogWrite(E1, Speed);  // Contrôle de la vitesse du moteur 1 avec la broche E1
}

// Fonction pour avancer le moteur 2
void M2_advance(char Speed) {
  digitalWrite(M2, HIGH);  // Le moteur 2 avance en utilisant la broche M2
  analogWrite(E2, Speed);  // Contrôle de la vitesse du moteur 2 avec la broche E2
}

// Fonction pour reculer le moteur 1
void M1_back(char Speed) {
  digitalWrite(M1, HIGH);  // Le moteur 1 recule en utilisant la broche M1
  analogWrite(E1, Speed);  // Contrôle de la vitesse du moteur 1 avec la broche E1
}

// Fonction pour reculer le moteur 2
void M2_back(char Speed) {
  digitalWrite(M2, LOW);  // Le moteur 2 recule en utilisant la broche M2
  analogWrite(E2, Speed);  // Contrôle de la vitesse du moteur 2 avec la broche E2
}

// Fonction pour stopper le moteur 1
void M1_stop() {
  analogWrite(E1, 0);  // Arrêt du moteur 1 en mettant la vitesse à 0
}

// Fonction pour stopper le moteur 2
void M2_stop() {
  analogWrite(E2, 0);  // Arrêt du moteur 2 en mettant la vitesse à 0
}

// Configuration initiale
void setup() {
  // Configuration des broches des moteurs (entrée/sortie)
  for (int i = 3; i < 9; i++) {
    pinMode(i, OUTPUT);  // Configurer les broches de 3 à 8 en sortie
  }
  for (int i = 11; i < 13; i++) {
    pinMode(i, OUTPUT);  // Configurer les broches 11 et 12 en sortie
  }

  // Pause initiale de 10 secondes pour préparer les branchements
  delay(10000);  // Délai de 10 secondes avant de commencer
}

// Boucle principale où les actions sont répétées indéfiniment
void loop() {
  // 1er côté : Avancer tout droit
  M1_advance(100);  // Moteur gauche avance à pleine vitesse
  M2_advance(100);  // Moteur droit avance à pleine vitesse
  delay(2000);      // Temps pour avancer le premier côté du carré

  // Tourner à droite (90°)
  M1_advance(100);  // Moteur gauche avance rapidement
  M2_advance(10);   // Moteur droit avance lentement pour effectuer un virage à droite
  delay(500);        // Délai ajustable pour réaliser un virage de 90° (ajuste si nécessaire)

  // 2ème côté : Avancer tout droit
  M1_advance(100);  // Moteur gauche avance
  M2_advance(100);  // Moteur droit avance
  delay(2000);      // Temps pour avancer le deuxième côté du carré

  // Tourner à droite (90°)
  M1_advance(100);  // Moteur gauche rapide
  M2_advance(10);   // Moteur droit lent pour virage à droite
  delay(500);        // Temps de virage pour tourner à droite

  // 3ème côté : Avancer tout droit
  M1_advance(100);  // Moteur gauche avance
  M2_advance(100);  // Moteur droit avance
  delay(2000);      // Temps pour avancer le troisième côté du carré

  // Tourner à droite (90°)
  M1_advance(100);  // Moteur gauche rapide
  M2_advance(10);   // Moteur droit lent pour virage à droite
  delay(500);        // Temps de virage pour effectuer le virage à 90°

  // 4ème côté : Avancer tout droit
  M1_advance(100);  // Moteur gauche avance
  M2_advance(100);  // Moteur droit avance
  delay(2000);      // Temps pour avancer le quatrième côté du carré

  // Retourner en arrière pour faire le carré à l'envers (à reculons)

  // 1er côté en arrière : Reculer tout droit
  M1_back(100);  // Moteur gauche recule
  M2_back(100);  // Moteur droit recule
  delay(2000);   // Temps pour reculer le premier côté du carré à l'envers

  // Tourner à gauche (90°) pour revenir à l'envers
  M1_advance(10);   // Moteur gauche lent pour tourner à gauche
  M2_advance(100);  // Moteur droit rapide pour tourner à gauche
  delay(350);        // Temps de virage ajustable pour tourner à gauche

  // 2ème côté en arrière : Reculer tout droit
  M1_back(100);  // Moteur gauche recule
  M2_back(100);  // Moteur droit recule
  delay(2000);   // Temps pour reculer le deuxième côté à l'envers

  // Tourner à gauche (90°) pour revenir à l'envers
  M1_advance(10);   // Moteur gauche lent pour virage à gauche
  M2_advance(100);  // Moteur droit rapide
  delay(350);        // Temps de virage pour tourner à gauche

  // 3ème côté en arrière : Reculer tout droit
  M1_back(100);  // Moteur gauche recule
  M2_back(100);  // Moteur droit recule
  delay(2000);   // Temps pour reculer le troisième côté à l'envers

  // Tourner à gauche (90°) pour revenir à l'envers
  M1_advance(10);   // Moteur gauche lent pour virage à gauche
  M2_advance(100);  // Moteur droit rapide
  delay(350);        // Temps de virage pour tourner à gauche

  // 4ème côté en arrière : Reculer tout droit
  M1_back(100);  // Moteur gauche recule
  M2_back(100);  // Moteur droit recule
  delay(2000);   // Temps pour reculer le quatrième côté à l'envers

  // Stopper les moteurs
  M1_stop();  // Arrêter le moteur gauche
  M2_stop();  // Arrêter le moteur droit

  // Recommencer à partir du début pour refaire le carré
  delay(5000); // Pause avant de recommencer
}

---

🪚 Découpe Laser

1) Prise de mesures :

Nous avons commencé par relever avec précision les dimensions de la plateforme mobile:

• Largeur, longueur et hauteur disponibles
• Positions des éléments fixes (Arduino, moteurs, roues)
• Zones à laisser dégagées pour permettre la rotation libre des roues.

Ces mesures étaient essentielles pour concevoir une boite qui protège l'Arduino sans gêner le fonctionnement du châssis. 

2) Génération de la boite avec MakerCase :

Après avoir relevé les dimensions, nous avons utilisé MakerCase, un générateur en ligne de boîtes personnalisées.
Les étapes ont été les suivantes :

• Entrer les dimensions internes de la boîte correspondant au support

• Choisir une boîte ouverte pour permettre l’accès à l’Arduino

• Définir l’épaisseur du matériau utilisé : MDF de 3 mm

• Télécharger le fichier vectoriel (.svg) prêt pour la découpe laser.

3) Ajout et préparation des logos :

Afin de personnaliser le support, nous avons décidé d'ajouter deux logos :

• Le logo Louly.Gurumi

• Le logo du Fablab

Les étapes réalisées :

• Récupération des logos en image (formats .png ou .jpg)

• Vectorisation des logos pour les convertir en tracés exploitables par la découpeuse sur Inkscape

• Attribution des couleurs spécifiques :

  • Rouge pour les lignes de découpe

  • Noir pour les zones destinées à être gravées

Cela permettait à la machine de distinguer automatiquement les opérations de gravure et de découpe.

4) Réglage de la découpe laser :

• Vérification de l’échelle et de l’emplacement des logos et du modèle de boîte

• Paramétrage du laser :

• Organisation optimale des pièces sur la planche pour minimiser les pertes de matériau.

La découpe laser a ensuite été lancée, suivie par l'assemblage de la boîte pour valider l'ajustement général.

---

🖨️ Impression 3D

1) Prise de mesures et réflexion sur les formes :

Avant toute modélisation, nous avons commencé par relever avec précision les dimensions nécessaires pour concevoir un dôme adapté au robot :

• Dimensions de la zone disponible sur la plaque supérieure du châssis (largeur/longueur).

• Hauteur maximale possible sans déséquilibrer le robot.

• Besoin d’un support arrondi pour fixer l'animal en crochet de manière stable.

Nous avons choisi de créer un dôme simple pour coller au mieux la forme d’une peluche, tout en limitant le poids pour ne pas gêner le mouvement du robot.

2) Modélisation 3D sur Tinkercad :

La modélisation a été réalisée sur Tinkercad en suivant les étapes suivantes :

• Création d'un dôme solide de 10 cm de rayon et 14 cm de hauteur.

• Simplification du modèle pour éviter des supports internes inutiles.

• Ajout d'un volant et d'un siège dans un second temps pour renforcer l’aspect esthétique du robot.

Astuces : 

• Le dôme a été volontairement semi-plein, car la tentative d’avoir un creux n'était pas stable à l'impression.

• Pour le siège, nous avons formé un angle droit pour éviter d'avoir besoin de supports supplémentaires.

3) Extraction sur IdeaMaker :

Après la modélisation, les fichiers ont été exportés au format .stl et préparés sur IdeaMaker :

• Hauteur de couche : 0,3 mm (impression rapide et correcte pour des pièces non-détaillées)

• Densité de remplissage : 5 % (très faible pour réduire le temps et le poids)

• Motif de remplissage : Grille (plus rapide et suffisant pour le dôme)

• Supports d’impression :

  • Aucun support pour le dôme (surface simple et stable)

  • Supports activés pour le volant (formes en porte-à-faux plus fragiles)

4) Lancement et réussite de l’impression :

L'impression du dôme s'est déroulée sans problème :

• Temps d'impression : 8h20 min

• Quantité de filament utilisée : 120 g environ

• Aucun besoin de reprise ni de correction après impression.

Le volant et le siège ont également été imprimés correctement :

• Temps d'impression : 6h23 min
• Quantité de filament utilisée : non connue
• Ajout de support obligatoire pour le volant 
• Aucun besoin de reprise ni de correction après impression 

Paramètres d’impression IdeaMaker utilisés :

• Imprimante : Raise3D E2

• Filament : PLA 1.75 mm

• Remplissage : 5 %, motif grille

• Supports : Oui uniquement pour les pièces complexes (volant)

• Adhérence : Jupe uniquement

• Épaisseur de couche : 0,3 mm

Notes complémentaires :

1. Le choix d’une faible densité et d’un motif grille --> solidité et rapidité d’impression.
2. Réussite du premier coup --> stabilité du modèle créé.

• Modélisation 3D du dome sur TINKERCAD 

• Extraction du dome sur IDEAMAKER et paramètres d'impression 

Hauteur de couche : 0,3mm

Impression intérieur : initiale --> Gyroïde vs finale --> Grille pour optimiser le temps d'impression 

Densité de remplissage : 5% (faible car pas nécessaire comme on a fait un trou directement sur modélisation tikercad)

• Extraction du siège et du volant sur IDEAMAKER

---

✅ Tests, essais & ajustements

Tests & ajustements de la partie impression 3D :

• Ajustement forme du dôme pour stabiliser la peluche
  

Tests & ajustements de la partie découpe laser :

• Première itération: Plaque lisse avec quatre trous

Initialement, nous avons conçu une simple plaque plate avec quatre trous pour fixer l’Arduino via des vis.
Problème rencontré : La plaque ne tenait pas solidement, car l’Arduino monté en dessous déséquilibrait l’ensemble.

• Deuxième itération: boite en plexiglas

Pour améliorer la stabilité, nous avons réalisé une boîte en plexiglas.
Problème rencontré : Le matériau étant très lisse, la boîte glissait sur la plateforme, ce qui rendait l’installation instable.

• Troisième itération: boite en MDF 3mm 

Nous avons remplacé le plexiglas par une boîte identique réalisée en MDF 3 mm et pour plus de stabilité nous avons utilisé la colle pour bien fixer la boite. 18x13x7cm
Résultat : L’adhérence était meilleure.
Problème rencontré : La boîte était trop juste et bloquait le mouvement des roues.

• Quatrième itération: Agrandissement de la boite

Pour corriger ce problème, nous avons augmenté la largeur et la longueur de la boîte de 0,5 cm chacun, tout en conservant la même hauteur. Nous avons aussi augmenté le nombre d'indentations afin de stabiliser et sécurisé le montage. La colle a aussi été utilisée. 19x14x7cm
Résultat : L’espace était meilleur, mais encore légèrement insuffisant pour un mouvement totalement fluide.

Nous avons aussi remis la carte Arduino et la pile à l'intérieur du châssis ainsi que la pile. Le tout a été sécurisé grâce à des vis. 

decoupelaserfinale.svg

• Cinquième itération: Surélévation de la plateforme

Pour finaliser l'ajustement, nous avons légèrement surélevé la plateforme mobile, afin de libérer totalement les roues.
Résultat final : La boîte protège l’Arduino tout en permettant un mouvement libre et sans blocage.

---

📦 Réalisation physique

• Montage Arduino + shield + châssis

• Impression du dôme, du siège et du volant (Tinkercad → IdeaMaker)

• Découpe laser du capot avec dents pour imbrication

• Gravure logo “Louly.gurumi” sur la plaque

• Crochetage de l'animal sur le dôme 

• Pose de la peluche sur le capot

---

📸 Photos

• Montage du châssis 

• Confection de l'animal crocheté autour du dôme

• Résultat Final

Lien de la vidéo de notre projet en mouvement : https://youtube.com/shorts/L2Dp8pRzIIg?feature=share

---

🔁 Pistes d’amélioration

• Ajouter des capteurs (obstacle, lumière) pour augmenter la complexité

• Ajouter des effets de sons ou de lumière pour augmenter les interactions

• Rendre le robot autonome via un contrôle bluetooth ou appli mobile

• Utiliser une batterie rechargeable + interrupteur ON/OFF
  

---

📚 Sources & inspirations

• Tinkercad pour modélisation du dôme

• Inkscape pour la gravure laser

• Tutoriels IRremote Arduino

• Random Nerd Tutorials

• Documentation du FabLab Sorbonne

• Tutoriel pour construire le châssis
• https://github.com/DFRobot/pxt-motor et https://wiki.dfrobot.com/Quad_Motor_Driver_Shield_for_Arduino_SKU_DRI0039 pour le contrôle des moteurs du châssis