Projet final prototypage Louly Chloé Eloïse

🎯 Définition du projet

Nom du projet : Une mise en avant originale pour Louly.gurumi - 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.

---

👥 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 chassis 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

• Design attendu du robot + capot + peluche crochetée

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

• Schéma du câblage Arduino + shield moteur

• 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)

• Slice du dôme sur IDEAMAKER 

---

🧾 Matériel utilisé

---

💻 Code Arduino 

Voici le code final que nous avons utilisé. Pour l'obtenir, nous avons itéré sur une version du code plus simplifiée, trouvée sur le site DFRobot (cf sources en fin de Wiki). A partir de ce modèle, nous avons modifié la trajectoire pour la complexifier.

// 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

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. 

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.

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.

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.

✅ Tests, essais & ajustements

Tests & ajustements de la partie impression 3D et découpe laser :

• Test d’adhérence du châssis + poids peluche
  

• 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.
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.
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. 

• 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.

Tests & ajustements de la partie code Arduino :

• Test moteurs : avec code minimal
• Test moteurs avec une trajectoire simple
• Ajustements de la trajectoire, pour qu'elle forme un carré, et ajustement des angles pour que ce soit bien des angles droits. Pour les ajustements du code, nous avons surtout réglé la vitesse de marche des roues ainsi que la durée de marche. Ces deux paramètres permettent ainsi de régler la rotation des roues (pour se faire : il faut baisser la vitesse d'une des deux roues et d'augmenter celle de l'autre).

Pour toute la partie code, nous avons mis 1 jour pour faire fonctionner les moteurs sans l'alimentation par le câble USB. 

Le problème résidait dans le fait qu'il n'y avait pas de connexion directe entre le shield et l'Arduino. Nous avons donc dû les relier manuellement avec des câbles pour que la voiture fonctionne à distance !

---

📦 Réalisation physique

• Montage Arduino + shield + châssis

• Impression du dôme (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 à intégrer

• Montage du châssis 

• Impression du capot 

• Gravure laser 

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

---

🔁 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

• 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 chassis