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 pour enfants avec détecteur de mouvement s'inscrit dans cette démarche.

Ce projet vise à concevoir une veilleuse en bois, de forme inspirée par la nature, qui s’intègre harmonieusement dans une chambre d’enfant. En combinant des LED pour un éclairage doux et économique, ainsi que des capteurs de luminosité et de mouvement pour une utilisation intuitive, cette lampe répond aux besoins de confort nocturne. Le support, conçu pour être emboîté sans outils, favorise aussi une approche durable et écologique, et permet de simplifier l'assemblage.

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.

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 :

A mettre ici le tableau finalisé

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

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 du Support en Bois

Le support de la lampe est conçu pour être découpé au laser, permettant une précision optimale dans les formes et les détails, notamment pour les emboîtements. La structure principale est découpée en deux parties plates qui s’assemblent en forme d’arbre, offrant un aspect décoratif et naturel. La découpe laser assure également la propreté des lignes et des détails, garantissant une finition esthétique et sécurisée.

prototype arbre 1.jpg

Prototype 1 du support principal en bois à emboiter au niveau de la base du tronc :

Le premier prototype du support en bois de la lampe, découpé au laser et assemblé en forme d'arbre. Ce design a été conçu pour s'emboîter sans nécessiter de colle ni de vis, assurant une bonne stabilité.

Cependant, l'arbre avec les branches apparaît quelque peu vide, soulignant la nécessité d'ajouter des éléments pour enrichir son apparence. À ce stade, ce prototype ne prend pas encore en compte la partie électronique. Les prochaines étapes se concentreront sur l'intégration des composants électroniques, tels que l'Arduino et les LED, tout en optimisant la forme pour renforcer la stabilité et améliorer l'esthétique de la lampe.

Prototype 2 du support principal en bois à emboiter au niveau de la base du tronc (format alternatif) :

Ce prototype présente une forme alternative du design initial : L’arbre classique a été remplacé par une forme d’arbre évoquant un nuage, offrant une structure avec des trous dans l'optique de faire passer le fil de LED à travers.

Prototype 3 de la lampe en bois encastrée dans une boite :
Ce prototype présente une évolution significative du design initial : L’arbre classique a été remplacé par une forme d’arbre évoquant un nuage, offrant une structure plus pleine et homogène. Ce changement rend l’arbre visuellement attrayant, mais surtout plus pratique pour intégrer et aligner les LED. Cette nouvelle forme simplifie leur disposition.

En parallèle, l’arbre est directement encastré dans une boîte en bois, supprimant ainsi la nécessité d’une base emboîtable. Cette approche améliore considérablement la stabilité et réduit la complexité de l’assemblage. 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.

Enfin, ce prototype prend en compte l’intégration des composants électroniques, tels que l’Arduino et les LED, en prévoyant un espace dédié dans la boîte.

Prototype 4 des faces pour cacher le fil de LED + les pinces :

Dans ce troisième prototype, les LED sont intégrées directement sur l'arbre qui est encastrées dans la boîte qui contient les composants électroniques et les câblage nécessaire au fonctionnement des LED. Deux faces en bois découpées ont été ajoutées pour servir de cache. 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.

L’objectif principal de ces deux faces est d’améliorer l’apparence visuelle du prototype en rendant invisible toute la partie technique. Le rendu se concentre donc uniquement sur l'effet lumineux produit par les LED, donnant un aspect propre et esthétique. Pour assembler l'arbre et les 2 faces et les maintenir solidement en place, des pinces ont été utilisées.

Comment sommes nous parvenues à cela ?

Pour parvenir à obtenir nos créations en bois, nous avons utilisé différents outils tels que :

Le site Festi Info pour créer les faces du cube et le fichier vectorisé en format .svg
Le site Freepik pour trouver des illustrations de plantes, fleurs et insectes pour habiller les faces de notre boîte
Le logiciel Inkscape pour intégrer les dessins sur chaque face de la boîte et préparer le fichier servant à la découpe laser
Des plaques de peuplier (3 mm) compatibles avec la découpe laser pour la conception de chaque face de la boîte et de l'arbre
Une machine de découpe laser 2D Trotec et son logiciel pour le lancement de l'opération

Création de l'arbre :

En ce qui concerne la conception de notre arbre, nous avons commencé donc par tester plusieurs formes de ce dernier : arbre avec branches, arbre dont le houppier est en forme de nuage avec ou sans trous, ce qui fait un total de trois versions différentes. Pour cela, nous avons designé chacune d'elles sur Inkscape à l'aide de l'"outil crayon", avant de passer au découpage à la machine laser. En ce qui concerne le matériau, nous avons opté pour le peuplier 3mm, un choix qui permettra de nous positionner en tant qu'entreprise éco-responsable. Les premiers designs de nos arbres étaient accompagnés de supports afin qu'ils tiennent debout. Cependant, afin d'optimiser au mieux l'espace dans notre boîtier par la suite, nous avons décidé de nous séparer du support en intégrant une partie du tronc d'arbre dans le boîtier via une fente, sans que l'arbre ne puisse bouger (c'est ce que nous verrons dans un deuxième temps).

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 tout de même décidé de nous pencher sur la version de l'arbre dont le houppier est en forme de nuage sans trous pour la conception de notre prototype. Cela est principalement une question de praticité car cela nous a permis de placer nos leds de manière plus optimisée sur cette option de l'arbre.

Création de la boîte :

Ce boîtier est conçu dans un but précis : celui d'abriter tout le système électronique comme les plaques d'Arduino et les fils mais également de servir d'objet esthétique et ludique pour les enfants, toujours dans la continuité du thème initial.

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 les dessins voulus. 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 dessiné une petite 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 forcément un support.

Nous avons veillé à ce que le système électronique puisse être complètement abrité par la boîte. Sur cette base, nous avons établi des dimensions adaptées. En termes de brûlage, nous avons dû faire plusieurs tests avant d'aboutir à un résultat convaincant. 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 des différentes faces, en particulier de la base et du top avec les autres faces (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 empêchait certaines faces de s'emboîter correctement entre elles. En diminuant le paramètre à 0.13mm, le processus est devenu plus facilement faisable mais le même problème persistait au niveau de la base. Nous avons modifié le brûlage en le passant à 0.11mm finalement mais seulement pour la base.

B. Électronique : Arduino et Capteur de Mouvement

Arduino : L’Arduino sert de cerveau au projet, gérant les interactions entre le capteur de mouvement 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.

Code Arduino avec Explications Partie par Partie

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

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)

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 LEDs 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!");
}

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

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

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 LEDs : Deux fonctions : la première fonction active l'éclairage des LEDs en appliquant l'effet d'arc-en-ciel à la bande LED et la deuxième fonction éteint toutes les LEDs 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

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

C. Personnalisation Ludique avec 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 ou des éléments de nature (oiseau, écureuil, champignon) à la base de la lampe. Ces éléments décoratifs en PLA ajoutent une dimension interactive et permettent une personnalisation esthétique de la lampe.

Après avoir modélisé nos animaux sur le site Tinkercad, nous nous sommes aidées du logiciel Prusa Slicer directement téléchargeable sur Internet et des imprimantes Prusa disponibles au Fab Lab. Après avoir donc téléchargé le logiciel, nous avons pu y importer les animaux un par un 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 (celle que nous avons choisie étant la plus rapide), le filament (PLA pour notre part), 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 le processus.

Pour finir, nous avons disposé nos animaux autour de la lampe.

Voici le rendu en photo :

PROTOTYPE FINAL