Projet final - Aurélie, Iryna, Justine, Mayar

Compte Rendu du Projet Final :
Lampe Intelligente

I. Définition et Analyse du projet

Dans un monde de plus en plus connecté, la conception de produits destinés aux enfants évolue vers des solutions alliant technologie et design sécurisé. En parallèle, les parents cherchent des objets qui favorisent à la fois le confort et la sécurité dans les espaces de vie des plus jeunes. Le projet de création d’une lampe ludique pour enfants avec détecteur de mouvement et de luminosité s'inscrit dans cette démarche.

L’enjeu principal est de concevoir un objet non seulement fonctionnel mais aussi esthétique, qui encourage les bonnes pratiques énergétiques et rassure les enfants durant la nuit.

A. Réflexions sur la problématique et veille sur l'existant

L’objectif de cette partie est d’identifier les besoins et d’examiner les solutions existantes :

1. Analyse des besoins 

Afin de parvenir à développer un produit qui réponde aux mieux aux attentes de nos principaux utilisateurs (les enfants), voici les critères que nous avons pris en compte : 

• Sécurité : En raison de son public cible, la lampe doit être non seulement résistante mais aussi inoffensive en cas de manipulation ou de chute.
• Simplicité d’utilisation : Il est essentiel que la lampe soit facile à utiliser pour les enfants permettant ainsi un fonctionnement intuitif sans avoir à manipuler un interrupteur traditionnel, en particulier pour ceux qui ont du mal à l'atteindre.
• Esthétique et thématique : Les enfants recherchent une ambiance apaisante et un design ludique, ce qui favorise une atmosphère rassurante et agréable dans leur espace.
• Économie d’énergie : Il est important que la lampe réponde à un besoin de faible consommation d’énergie, tout en offrant une fonctionnalité pratique pour éviter une consommation électrique inutile. De plus, étant donné que les enfants ne pensent pas toujours à éteindre la lumière après leur utilisation, il est essentiel d'intégrer des solutions permettant de minimiser la consommation d'énergie, même lorsqu'ils oublient de l'éteindre.

2. Veille concurrentielle et innovations 

Une analyse des solutions existantes révèle que les lampes actuellement disponibles sur le marché, bien qu'efficaces dans leur conception standard, présentent des limites significatives lorsqu'il s'agit de répondre aux besoins spécifiques des enfants, tant en termes de design, de fonctionnalité, que de personnalisation. 

Voici un tableau récapitulatif des différentes solutions existantes : 

Afin d'illustrer la diversité de formes de lampes déjà existantes sur le marché, voici quelques images :

En résumé, voici nos constatations sur les lampes existantes sur le marché : 

• Cible : Les lampes conçues spécifiquement pour les enfants sont généralement tactiles, mais celles à détection de mouvement ne sont pas spécifiquement adaptées à ce public. Elles visent un usage général avec des designs classiques (Aukey, Auvon, etc.).

• Matériaux : Les matériaux utilisés sont principalement à base de plastique, sans référence explicite à des thématiques comme la nature ou des concepts éducatifs.

• Personnalisation : Les lampes actuelles n’offrent pas de dimension personnalisable (formes, décorations ou adaptations spécifiques aux goûts des enfants).

• Fonctionnalité : Bien que les lampes avec détecteur de mouvement soient pratiques, elles manquent souvent d’éléments ludiques ou engageants pour les enfants.

B. Notre solution

En prenant en compte les différents critères liés aux besoins récoltés précédemment, voici la solution que nous proposons : 

• Adaptée aux enfants : Une lampe au design ludique et unique, en forme d’arbre, pensée spécifiquement pour captiver l’imaginaire des enfants. Ses LED colorées sur la surface de l’arbre créent un univers joyeux et enchanteur, parfait pour leur environnement.

• Matériaux et thématique : Fabriquée en bois naturel, elle offre une alternative écologique et durable aux modèles traditionnels en plastique, tout en intégrant une thématique inspirée de la nature pour encourager la connexion avec l’environnement.

• Personnalisation : La forme de l’arbre peut être adaptée selon les préférences, et le support-boîtier qui maintient la lampe debout peut être gravé avec des décorations ou motifs personnalisés, rendant chaque lampe unique.

• Fonctionnement : Équipée de capteurs de luminosité et de mouvement, la lampe s’allume et s’éteint automatiquement sans contact, offrant une utilisation pratique et intuitive tout en favorisant l’autonomie des enfants.

II. Conception et Développement

La phase de conception et de développement se concentre sur l’assemblage des composants matériels et la programmation, permettant de créer une lampe interactive et ludique pour enfants.

A. Découpe des supports en bois

La lampe (en forme d'arbre) ainsi que son support en bois seront découpés au laser, permettant une précision optimale dans les formes et les détails, notamment pour les emboîtements. En effet, le boîtier qui servira de support à notre arbre, sera doté d'une fente qui permettra à l'arbre de s'y emboîter, garantissant ainsi sa stabilité. Ce support permettra également de cacher tout le système électronique dont nous parleront dans une seconde partie. La découpe laser assure également la propreté des lignes et des détails, garantissant une finition esthétique et sécurisée.

Matériels utilisés : 

Pour cela, voici le matériel que nous avons utilisé pour la découpe laser de notre arbre et le support associé : 

• Site internet Festi Info : pour créer les faces du cube et le fichier vectorisé en format .svg.

• Site internet Freepik : pour trouver des illustrations de plantes, fleurs et insectes destinées à habiller les faces de notre boîte.

• Logiciel Inkscape : pour intégrer les dessins sur chaque face de la boîte et préparer le fichier servant à la découpe laser.

• Plaques de peuplier (3 mm et 6mm) : compatibles avec la découpe laser pour la conception de chaque face de la boîte et la découpe de l'arbre.

• Machine de découpe laser 2D Trotec et son logiciel : pour le lancement du découpage.

Création de l'arbre : 

En ce qui concerne l'esthétique de notre arbre, nous avons commencé par tester plusieurs formes de ce dernier avant d'opter pour une version finale pour la conception de notre prototype :

• arbre avec branches,
• arbre dont le houppier est en forme de nuage avec des trous dans l'optique de faire passer les LED à travers,
• arbre dont le houppier est en forme de nuage sans trous. 

Pour cela, nous avons dessiné chacune de ces versions sur Inkscape à l'aide de l'"outil crayon". Pour nous aider dans les dessins et notamment pour pouvoir obtenir des traits droits, nous sommes allées chercher une image d'arbre de forme qui nous intéresse et nous l'avons importé sur Inkscape. Sur cette base, nous avons pu reproduire les traits des arbres importés et les utiliser pour la découpe laser.

En ce qui concerne le matériau, nous avons opté pour du peuplier 3mm, un choix qui permettra de nous positionner en tant qu'entreprise éco-responsable. Les premiers designs de notre arbre étaient accompagnés d'un support afin que l'arbre puisse tenir debout, mais cette idée a par la suite été remplacée par celle de l'emboîtement comme nous le verrons dans la section dédiée au découpage du boîtier. 

Certes, nos produits sont personnalisables, ce qui veut dire que nous sommes en mesure de proposer des formes et des designs variés, nous avons décidé de poursuivre avec la version de l'arbre dont le houppier est en forme de nuage sans trous pour la conception de notre prototype. Le choix de cette version s'explique par la praticité que nous offre ce design pour disposer nos LED.  

Prototype 1 : arbre avec branches

Prototype 2 : arbre en forme de nuage avec trous

Prototype 3 : arbre en forme de nuage sans trous

Création de la boîte : 

La deuxième étape de notre travail a été dédiée à la conception du boîtier servant de support pour l'arbre et de contenant pour le système électronique. Il a également pour rôle de servir d'objet esthétique et ludique pour les enfants grâce aux gravures qui l'habillent. 

Pour cela, nous nous sommes rendues sur le Festi Info où nous avons fini par trouver un boîtier simple, complètement fermé que nous avons téléchargé en format .svg pour pouvoir ensuite l'importer dans Inkscape et le décorer avec des dessins de nature trouvés sur Freepik. Nous avons bien veillé à ce que les images apposées sur les différentes faces soient vectorisées après leur importation sur Inkscape. Enfin, nous avons intégré une fente sur le top de la boîte pour y faire passer le tronc de notre arbre et lui permettre de rester debout sans utiliser un autre support. 

Nous avons veillé à ce que le système électronique puisse être abrité par la boîte. Nous avons donc pris en compte l'espace que nous occuperait ce système électronique et sur cette base, nous avons établi les dimensions de la boîte :

• largeur (x) : 130mm, soit 13cm,
• profondeur (y) : 130mm, soit 13cm,
• hauteur (h) : 50mm, soit 5cm.

En termes de brûlage, nous avons dû faire plusieurs tests avant de réussir à trouver la bonne valeur pour pouvoir assembler les différentes faces. En effet, nous avons démarré avec un brûlage de 0.15mm que nous avons fini par descendre à 0.11mm en raison de problèmes d'emboîtement entre les faces, en particulier de la base et du top avec les autres côtés (murs). Pour la première version (0.15mm), nous nous sommes rendues compte que l'espace entre les petites dents était très serré et les dents en elles-mêmes étaient assez larges, ce qui compliquait le processus. En diminuant le paramètre à 0.13mm, le problème persistait toujours au niveau de la base qui ne s'emboîtait pas avec les murs du boîtier. Nous avons donc fini par descendre le brûlage à 0,01mm pour la base seulement, ce qui a grandement facilité l'emboîtement.

Prototype 4 : boîtier gravé au laser

Lampe en bois encastrée dans le boîtier :

La boîte, gravée au laser avec des motifs ludiques tels que des plantes, des papillons et d'autres insectes, ajoute une dimension éducative et esthétique, idéale pour une veilleuse destinée aux enfants. Ces détails apportent une touche décorative qui stimule la curiosité et l’imagination.

Création des faces cache-fils (pour les LED) :

Sur les images ci-dessous, on peut voir la disposition que nous avons imaginée pour notre ruban de LED. Nous avons décidé de l'enrouler autour de l'arbre. Ainsi, pour cacher le ruban des LED, nous avons pensé à rajouter deux faces en peuplier 6mm de chaque côté de l'arbre. Ces faces possèdent des trous alignés précisément avec les LED, ce qui permet de dissimuler entièrement le fil LED tout en laissant passer uniquement la lumière des LED à travers les ouvertures.

Pour assembler l'arbre et les 2 faces et les maintenir solidement en place, des pinces ont été découpées également. 

Prototype 5 : faces cache-fils

Prototype 6 : pinces

B. Électronique : Arduino et capteurs de mouvement et luminosité

Matériels utilisés :

• Arduino : L’Arduino sert de cerveau au projet, gérant les interactions entre les capteurs de mouvement et de luminosité et les LED. Il est programmé pour détecter les mouvements et activer l’éclairage de la lampe lorsque quelqu'un s’approche.
  

• Capteur de Mouvement (PIR) : Un capteur infrarouge passif (PIR) est utilisé pour capter les mouvements dans un rayon proche de la lampe. Ce capteur envoie des signaux à l’Arduino lorsqu’un mouvement est détecté, déclenchant ainsi l'allumage des LED pour une durée préprogrammée.
  

• Capteur de Luminosité (Si1151) : Un capteur de lumière (Si1151) mesure la luminosité ambiante. Si l'environnement est suffisamment éclairé, il empêche l'allumage inutile des LEDs, permettant des économies d’énergie.
  
• LED : Les LED WS2812 sont choisies pour leur faible consommation d’énergie et leur capacité à produire des couleurs variées. L’intensité lumineuse et les effets dynamiques sont contrôlés par le programme, offrant une lumière douce et apaisante, idéale pour les chambres d’enfants.
  
  

Montage du circuit avec Arduino, Breadboard et LEDs: 

Le montage électronique repose sur l’utilisation d’une carte Arduino connectée à un breadboard, où les différents composants électroniques sont intégrés. Voici les étapes et une explication du montage :

1. Connexion des LEDs WS2812

   • Pin DATA : La broche DATA des LEDs est connectée à la broche numérique D13 de l'Arduino pour transmettre les signaux de contrôle.
   • Alimentation : Les broches VCC et GND des LEDs sont connectées respectivement à une source de 5V et au GND de l’Arduino via le breadboard.
   • Condensateur (100 µF) : Placé entre les broches d’alimentation des LEDs (5V et GND), ce condensateur permet de stabiliser la tension en évitant les fluctuations dues à la consommation variable des LEDs. Cela protège également les LEDs contre d’éventuels pics de tension qui pourraient les endommager.

2. Connexion du capteur de mouvement PIR

   • La sortie numérique du capteur PIR est connectée à la broche D2 de l’Arduino.
   • L’alimentation du capteur est assurée par les broches 5V et GND de l’Arduino.

3. Connexion du capteur de luminosité Si1151

   • Le capteur est branché sur le bus I2C de l’Arduino. 
   • Il est également alimenté par les broches 5V et GND.

4. Résistance de 220 ohms

   • Une résistance de 220 Ω est placée entre la broche D13 de l’Arduino et la broche DATA des LEDs WS2812. Cette résistance sert à limiter le courant entre l'Arduino et les LEDs, réduisant ainsi les interférences électriques et protégeant les LEDs contre les surtensions ou les variations rapides de signal.

5. Alimentation globale

   • Dans ce projet, l’alimentation est fournie exclusivement par l’Arduino, qui est connecté à l’ordinateur via un câble USB. Cette connexion fournit une tension de 5V suffisante pour alimenter l’ensemble du circuit, y compris les LEDs WS2812, le capteur de mouvement PIR, et le capteur de luminosité Si1151.

     Points importants :

     • Consommation des LEDs : Les LEDs WS2812 sont utilisées ici avec une intensité et un nombre limités, ce qui permet à l’alimentation de l’Arduino de suffire sans surcharger ses capacités.
     • Masse commune (GND) : Tous les composants partagent le même GND (terre commune) pour garantir une référence électrique stable dans le circuit. Cela évite des dysfonctionnements liés à des différences de potentiel.

     Ainsi, la simplicité de l’alimentation par l’Arduino, sans avoir besoin d’une source externe dédiée, rend le montage pratique et portable pour une utilisation légère, comme celle visée dans ce projet.

Ce montage assure une gestion efficace de la consommation d’énergie et une stabilité optimale pour le fonctionnement du projet. L’intégration sur breadboard facilite l’expérimentation et les ajustements nécessaires avant une version définitive.

Réglage du capteur de mouvement PIR

Le capteur de mouvement PIR dispose de deux potentiomètres ajustables pour configurer ses performances :

1. Réglage de la sensibilité (distance) :
   Ce paramètre détermine la distance maximale à laquelle le capteur peut détecter un mouvement. Dans ce projet, nous avons réglé la sensibilité pour une portée d’environ 1 mètre 20 cm.

   • Importance :
     Cela permet de limiter les déclenchements indésirables causés par des mouvements éloignés ou non pertinents, comme une personne passant dans une pièce voisine. Cela rend le système plus précis et adapté à une utilisation dans des espaces restreints, comme une chambre d’enfant.

2. Réglage du délai de maintien (durée) :
   Ce paramètre contrôle le temps pendant lequel le capteur maintient son signal de détection actif après avoir détecté un mouvement. Nous avons réglé ce délai à environ 20 secondes.

   • Importance :
     Ce réglage permet de maintenir les LEDs allumées pendant un intervalle suffisant pour assurer un éclairage confortable après une détection de mouvement. Cela évite des allumages et extinctions trop rapides, qui pourraient être désagréables ou stressants, surtout pour les enfants.

En combinant ces deux réglages, le système devient mieux adapté à l’environnement d’utilisation, offrant un éclairage intelligent, économe en énergie et agréable à utiliser.

Code Arduino avec explications partie par partie : 

Voici le code utilisé, avec des commentaires expliquant chaque partie de son fonctionnement :

1. Inclusion des bibliothèques et configuration des variables : 
   - Bibliothèque FastLED : Contrôle les bandes LED.
   - Bibliothèques SI114X et Si115X : Gèrent le capteur de luminosité.
   - PIR_MOTION_SENSOR : Définit le pin du capteur PIR (entrée numérique).
   - DATA_PIN : Pin connecté à la bande LED.
   - NUM_LEDS : Nombre de LEDs dans la bande.
   - lightThreshold : Niveau de lumière pour considérer qu'il fait sombre.
   - onlyAtNight : Active les LEDs uniquement la nuit si true.
   
   

   #include <Wire.h>
   #include <FastLED.h>
   #include "SI114X.h"
   #include "Si115X.h"
   
   // -------------------- LED Configuration -------------------- //
   #define DATA_PIN    13       // Pin connected to the LED strip
   #define LED_TYPE    WS2812   // Type of LEDs used (WS2812)
   #define COLOR_ORDER GRB      // Color order (Green, Red, Blue)
   #define NUM_LEDS    60       // Total number of LEDs on the strip
   CRGB leds[NUM_LEDS];         // Array representing the LEDs
   
   // -------------------- LED Constants -------------------- //
   #define BRIGHTNESS  96       // Brightness of the LEDs (range: 0 to 255)
   
   // -------------------- Sensor Pins -------------------- //
   #define PIR_PIN 2            // PIR sensor connected to pin 2
   Si115X SI1145 = Si115X();    // Object to interact with the SunLight sensor (analog interface)
   
   // -------------------- Initial States -------------------- //
   bool ledsAreOn = false;      // State variable to track the status of the LEDs
   int rainbowHue = 0;          // Hue used for the rainbow effect
   float lightThreshold = 10.0; // Threshold for considering "dark" conditions
   bool onlyAtNight = false;    // Activate LEDs only in the dark (set to false to activate day and night)
   
   

   
   
2. Initialisation dans setup() :
   Cette fonction initialise le système. Elle configure les pins pour le capteur PIR, lance la communication série pour afficher les messages de diagnostic, et initialise la bande LED avec la bibliothèque FastLED. Elle vérifie aussi que le capteur de luminosité Si1151 est prêt avant de continuer. Enfin, elle s'assure que les LED sont éteintes au démarrage. 
   
   

   // --------------------------- Initialization --------------------------- //
   void setup() {
     // Initialize pins and serial port
     pinsInit();
     Serial.begin(9600);
     Serial.println("Initializing system...");
     
     // Initialize the LED strip with the FastLED library
     FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
     FastLED.setBrightness(BRIGHTNESS);
     turnOffLEDs();  // Ensure LEDs are off at the start
   
     // Initialize the Si1151 light sensor
     while (!SI1145.Begin()) {
       Serial.println("Si1151 sensor not ready! Retrying...");
       delay(1000);  // Retry every second
     }
     Serial.println("Si1151 sensor initialized successfully!");
   }

3. Boucle Principale loop()  : 
   Cette fonction est exécutée en boucle. Elle détecte les mouvements grâce au capteur PIR et mesure le niveau de lumière ambiante avec le capteur Si1151. Si un mouvement est détecté et que les conditions de luminosité sont remplies (sombre ou configuré pour fonctionner jour et nuit), elle allume les LED avec un effet d'arc-en-ciel. Si aucun mouvement n'est détecté ou si les conditions de luminosité ne conviennent pas, elle éteint les LED.
   

   // -------------------------- Main Loop -------------------------- //
   void loop() {
     // Check the state of the PIR motion sensor
     bool motionDetected = isPeopleDetected();
     
     // Measure ambient light level (IR)
     float uvLevel = (float)SI1145.ReadIR();
   
     // Determine if the environment is dark
     bool isDark = (uvLevel < lightThreshold);
   
     // If motion is detected and light conditions are met
     if (motionDetected && !ledsAreOn && (isDark || !onlyAtNight)) {
       ledsAreOn = true;  // Update LED status
       if (onlyAtNight)
       {
       Serial.println("Motion detected and it's dark. Turning ON the LEDs.");
       }
       if (!onlyAtNight)
       {
       Serial.println("Motion detected. Turning ON the LEDs.");
       }
       turnOnLEDs();  // Turn on LEDs with rainbow effect
     }
     // If no motion is detected and LEDs are on
     else if (!motionDetected && ledsAreOn) {
       turnOffLEDs();  // Turn off LEDs
       ledsAreOn = false;  // Update LED status
       Serial.println("No motion detected. Turning OFF the LEDs.");
     }
     // If it is too bright and LEDs are set to work only at night
     else if (!isDark && onlyAtNight) {
       turnOffLEDs();  // Turn off LEDs
       ledsAreOn = false;  // Update LED status
     }
   
     delay(200);  // Small delay to avoid an overly fast loop
   }

4.  Fonctions Auxiliaires : 
   - Détection de Mouvement : Cette fonction vérifie l'état du capteur PIR. Elle lit la valeur du capteur et renvoie true si un mouvement est détecté, sinon false.
   
   

   // --------------------- Function: Motion Detection --------------------- //
   boolean isPeopleDetected() {
     int sensorValue = digitalRead(PIR_MOTION_SENSOR);  // Read PIR sensor state
     return (sensorValue == HIGH);  // Return true if motion is detected
   }

   
   - Initialisation des Pins : Cette fonction configure les pins nécessaires au fonctionnement du capteur PIR. Elle les initialise en tant qu'entrées et affiche un message de confirmation dans le moniteur série.
   
   

   // --------------------- Function: Pin Initialization --------------------- //
   void pinsInit() {
     pinMode(PIR_MOTION_SENSOR, INPUT);  // Configure PIR sensor as input
     Serial.println("Pins initialized.");  // Confirmation message
   }

   
   - Allumer/Éteindre les LED : Deux fonctions : la première fonction active l'éclairage des LED en appliquant l'effet d'arc-en-ciel à la bande LED et la deuxième fonction éteint toutes les LED en les configurant sur la couleur noire (CRGB::Black). 
   
   

   // --------------------- Function: Turn On LEDs --------------------- //
   void turnOnLEDs() {
     showRainbow();  // Display the rainbow effect
   }
   
   // --------------------- Function: Turn Off LEDs --------------------- //
   void turnOffLEDs() {
     for (int i = 0; i < NUM_LEDS; i++) {
       leds[i] = CRGB::Black;  // Set each LED to "off"
     }
     FastLED.show();  // Apply the changes
   }
   

   
   - Effet Arc-en-Ciel: Cette fonction applique un effet d'arc-en-ciel sur la bande LED. Chaque LED reçoit une couleur différente calculée à partir de la teinte actuelle. L'effet est animé en modifiant légèrement la teinte après chaque affichage.
   
   

   // --------------------- Function: Rainbow Effect --------------------- //
   void showRainbow() {
     for (int i = 0; i < NUM_LEDS; i++) {
       // Calculate the color of each LED for the rainbow effect
       leds[i] = CHSV((rainbowHue + ((NUM_LEDS - i) * 256 / NUM_LEDS)) % 256, 255, 255);
     }
     FastLED.show();  // Apply changes to the LEDs
     rainbowHue++;  // Slightly change the hue for animation
   }

   
   

Résumé du Fonctionnement

1. Initialisation : L’Arduino configure les capteurs et LED.
2. Détection : Les capteurs détectent le mouvement et mesurent la lumière ambiante.
3. Réponse : Si un mouvement est détecté dans un environnement sombre, les LED s'allument avec des animations dynamiques.
4. Économie d’énergie : Les LED s’éteignent automatiquement en l’absence de mouvement ou si l’environnement est suffisamment éclairé.

C. Personnalisation ludique avec l'imprimante 3D

Afin de rendre la lampe plus attrayante pour les enfants, une imprimante 3D est utilisée pour ajouter des éléments ludiques, comme des animaux, à la base de cette dernière. Ces éléments décoratifs en plastique ajoutent une dimension interactive et permettent une personnalisation esthétique de la lampe.

Matériels utilisés :

• Site internet Tinkercad : pour la modélisation 3D des animaux (panda, chat, canard, girafe) et l'export en format .stl.
• Logiciel Prusa Slicer : pour l'adaptation des paramètres d'impression (supports, choix de l'imprimante 3D, remplissage, etc).
• Filament PLA : matériau utilisé par l'imprimante 3D pour la création des figurines.
• Imprimante 3D : pour l'impression des animaux.

Création des figurines : 

Après avoir modélisé nos animaux sur le site Tinkercad à l'aide des différents outils proposés (figures géométriques simples : cube, sphère, triangle, etc), nous nous sommes aidées du logiciel Prusa Slicer directement téléchargeable sur internet, et des imprimantes 3D Prusa disponibles au Fab Lab.

Ainsi, après avoir enregistré nos modélisations 3D en format .stl via Tinkercad, nous avons pu importer les animaux un par un sur Prusa Slicer avant d'ajuster leurs tailles et leurs placements grâce aux commandes disponibles sur le côté gauche de l'écran (déplacer, redimensionner, rotation).

Pour lancer l'impression, nous avons dû régler quelques paramètres tels que les réglages d'impression qui consistent à définir la vitesse d'impression (0.28mm DRAFT (modifié) étant la plus rapide), le filament (PLA), choisir l'imprimante, l'application du support et le pourcentage de remplissage.

Afin de pouvoir enlever facilement les supports sur nos animaux, nous avons opté pour des supports organiques. Pour cela, nous nous sommes rendues dans l'onglet "Réglages d'Impression", puis dans "Supports", avant de cocher la case "Générer des supports" et choisir le style "organique" pour nos supports. 

Et voici le résultat lorsque nous sommes revenues sur la page principale ("Plateau") et avons cliqué sur "Découper maintenant" : 

Par la suite, nous avons sélectionné "Exporter le G-code", avant d'enregistrer le rendu et de le transmettre sur la clé USB destinée aux imprimantes 3D Prusa. La dernière étape consiste à insérer la clé USB dans l'imprimante et de lancer l'impression.

Prototype : figurines d'animaux en impression 3D

PROTOTYPE FINAL

D. Perspectives d’Évolution du Produit

Il existe plusieurs pistes d'amélioration pour enrichir notre lampe : 

Mode Éco-intelligent :

L'ajout d'un bouton permettrait d'implémenter un "Mode Éco-intelligent" avec deux options de fonctionnement :

1. Mode Green : Dans ce mode, la lampe ne s'allumerait que lorsque deux conditions sont réunies : détection de mouvement ET faible luminosité ambiante. Cela maximiserait les économies d'énergie en évitant tout éclairage superflu.
2. Mode Standard : En appuyant à nouveau sur le bouton, la lampe passerait en mode standard, s'allumant à chaque détection de mouvement, indépendamment de la luminosité ambiante. 

L'implémentation de cette fonctionnalité nécessiterait :

• L'ajout d'un bouton physique sur le boîtier,
• La modification du code Arduino pour intégrer la gestion des deux modes,
• Une interface visuelle simple (par exemple, une LED de couleur différente) pour indiquer le mode actif.