# Projets d'UE 2024-2025 (suite)
# MU4CIOIP - Projet Jeu de Taquin/QR Code
Notre projet est de réaliser un jeu de taquin permettant d'obtenir un QR code, nous emmenant vers un site web contenant des vidéos pour la journée du village des futurs souhaitables.
Nous avons trouver un modèle de jeu de taquin 3x3 sur ce lien suivant : [https://www.thingiverse.com/thing:2918039](https://www.thingiverse.com/thing:2918039)
# Projet flamme olympique
# Projet Flamme olympique
#### Informations
- Membre du projet : Habib AFFANE , Adil Haidaraly , Bilal BERRICH , Lounes Ait-BENAMARA, Lyna MAHIOUT
- EMAIL : habib.affane@etu.sorbonne-universite.fr
- CURSUS : 2ème année Licence complémentaire métiers de la mécanique ( En convention avec CFA Mécavenir )
- UE : ME225 : Découverte des procédés industrielle
- Chargé d'UE : Mr Christophe GUEPIN
- Date de début : 21-11-2024
#### Contexte
Création d'une flamme olympique ( JO 2024 ) en formant des pièces puzzle en utilisant du bois, la machine découpe laser et l'impression 3D.
La construction des pièces est faite par la modélisation et la conception en utilisant le logiciel SolidWorks .
Constituant du modèle:
- Un support
- des flammes olympiques
- Un arc
- Le logo des JO PARIS 2024
#### Objectifs
- Approfondir les connaissances en modélisation et conception mécanique
- La transformation des pièces en 2D vers 3D en utilisant des machine modernes comme la découpe laser et l'impression 3D.
- La préparation de notre insertion en milieu professionnelle ( Alternance en entreprise pour l'année universitaire 2024-2025 .
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/1000012701.jpg)[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2024-11/1000012361.jpg)
#### Matériel
- 1 planche de CP peuplier 3mm (dimensions 300\*600mm)
- scotch de peintre
- colle à bois
- cutter
- papier de verre grain moyen (80-100)
#### Machines utilisées
Machine découpe laser
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/books/projet-due-2024-2025-espace-biologiechimie/page/projet-flamme-olympique/edit?content-id=bkmrk-machine-impression-3&content-text=Machine%20impression%203D "Jump to section in editor")
Machine impression 3D
# Prototypage Arduino - Rita MATAR, Yasmine HAMED, Maélanne REVOL & Marya EL NOUEIRY
# **Introduction à Arduino**
## **1. Les outils et leurs utilisations**
Avant de commencer à programmer et à monter des circuits avec Arduino, il est essentiel de comprendre les composants de base et leur rôle :
- **LED (Diode électroluminescente)** :
- Permet le passage du courant dans un seul sens.
- Possède une patte plus courte correspondant à la borne négative (cathode).
- A une très faible résistance.
- **Résistance** :
- Permet de limiter le courant circulant dans un circuit.
- Utilise la loi d’Ohm : **U = R × I** (U : tension, R : résistance, I : courant).
- La pile peut compenser les variations de courant.
- **Condensateur** :
- Stocke et libère l’énergie électrique selon les besoins du circuit.
- **Potentiomètre** :
- Permet de faire varier la tension.
- Utilisé pour permettre à l’Arduino d’interagir avec l’utilisateur.
- **Transistor** :
- Permet de contrôler des tensions plus élevées avec Arduino.
- Par exemple, un moteur fonctionnant en 12V (trop élevé pour l’Arduino) peut être piloté à l’aide d’un transistor.
- **Régulateur de tension** :
- Permet de convertir une tension de 12V en 5V pour adapter l’alimentation des composants.
---
## **2. Premiers pas avec Arduino IDE**
Pour programmer notre Arduino, nous avons ouvert **Arduino IDE** et accédé à un exemple de code en suivant ces étapes :
1. **Ouverture d’un exemple de code Blink** :
- Aller dans **File > Examples > Basics > Blink**.
- Vérifier que la carte Arduino est bien sélectionnée :
- **Tools > Board > Arduino AVR > Arduino Uno**.
- **Tools > Port > Dev CU** (sélectionner le premier port détecté).
2. **Test de la carte Arduino** :
- Nous avons d’abord vérifié que l’Arduino fonctionnait correctement en chargeant le programme Blink, qui fait clignoter une LED embarquée.
- Ensuite, nous avons modifié la durée du clignotement en changeant la valeur des délais (de 1000ms à 5000ms).
---
## **3. Réalisation des premiers montages**
### **Premier montage : LED clignotante**
Nous avons réalisé notre premier circuit en utilisant :
- Une **LED**.
- Une **résistance** pour limiter le courant.
Ensuite, nous avons écrit un programme permettant de faire clignoter la LED.
- [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/S1Gimg-9426.JPG)
Il faut mantenant faire le code pour faire glignonté la LED :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/whatsapp-image-2025-02-07-at-11-08-40.jpeg)
---
### **Deuxième montage : Bouton-poussoir**
Après avoir appris à faire clignoter une LED, nous avons ajouté un **bouton-poussoir** alimenté en **5V**.
1. Nous avons téléversé un programme permettant de détecter l’appui sur le bouton.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/img-9427.JPG)
2. Après l’upload du code, nous avons ouvert le **moniteur série** :
- Aller dans **Tools > Serial Monitor**.
- Une fenêtre s’affiche indiquant lorsque le bouton est pressé.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/whatsapp-image-2025-02-07-at-11-41-42.jpeg)
---
### **Troisième montage : Potentiomètre**
Nous avons ajouté un **potentiomètre** au circuit.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/img-9428.JPG)
- En tournant le potentiomètre, la tension de sortie varie.
- Cette variation est détectée par l’Arduino et affichée sur le moniteur série.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/whatsapp-image-2025-02-07-at-12-01-46.jpeg)
---
### **Quatrième montage : Capteur I2C**
Nous avons expérimenté l'utilisation d'un **capteur communicant en I2C**, tel que :
- Un **capteur de luminosité**.
- Un **capteur de température**.
- Un **capteur d’humidité**.
Le branchement des capteurs I2C se fait sur les broches **SDA** et **SCL**. Pour connecter ces capteurs, nous avons utilisé un **shield** qui se place par-dessus la carte Arduino.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/whatsapp-image-2025-02-07-at-11-08-40.jpeg)
Il faut maintenant chercher le code correspondant à notre capteur dans la librairie de l’application Arduino IDE. Dans notre cas, il s’agit du capteur SHT35.
Ci-dessous, le montage du capteur :
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/img-9430.jpeg)
Code correspondant au capteur SHT35: [](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/capture-decran-2025-02-07-a-14-53-15.jpeg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/capture-decran-2025-02-07-a-14-53-47.jpeg)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/capture-decran-2025-02-07-a-14-53-52.jpeg)
### **Cinquième montage:**
On branche une led ainsi qu’une résistance sur notre montage Arduino, shield et capteur thermique et d’humidité.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/img-9432.jpeg)
En réchauffant le capteur avec nos mains, on peut faire augmenter la température autour du capteur et ainsi allumer la led (à partir de 23°C). On observe qu’en retirant nos mains, la led s’éteint lorsqu’elle passe en dessous du seuil des 23°C.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/img-9433.jpeg)
### **Sixième montage:**
Branchement du cerveau moteur:[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/img-3988.jpeg)Code servant à faire bouger le servo moteur grâce au potentiomètre:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/xvIcapture-decran-2025-02-07-a-15-30-28.jpeg)
Code servant à faire bouger le servo moteur seul:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/image-png.jpeg)
**OBJECTIF POUR LA PROCHAINE FOIS : **
=> Créer un code qui combine ce qu’on a vu aujourd’hui.
Ce qu’on veut faire: utiliser le capteur pour pouvoir faire monter la température et donc faire bouger le servo moteur à partir de 23°C.
**OBJECTIF POUR LE VENDREDI 7 MARS : **
Lors de ce cours, nous avons découvert l'application **Tinkercad** afin de créer et imprimer un objet en 3D.
Nous avons d'abord eu l'idée de réaliser un **couteau suisse** comprenant un couteau, un tire-bouchon, un tournevis et une fourchette. L’objectif était de maintenir l’ensemble grâce à des vis.
Cependant, après plusieurs réflexions et essais pour concevoir le tire-bouchon, nous avons réalisé qu'il serait peut-être difficile à fabriquer avec la bande passante dont nous disposions.
Nous avons donc décidé de simplifier notre projet en créant un **couteau suisse avec des couverts**. Puis, en poursuivant notre réflexion, une nouvelle idée a émergé : réaliser un **porte-clés en forme de couverts**.
Nous avons commencé par dessiner la **fourchette** en utilisant les nouveaux outils de dessin (sketch) disponibles dans Tinkercad.
Puis nous avons créé la **cuillère** en fusionnant la sphère et le manche.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-03/zsIimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-03/Fp7image.png)
Création cuillère : percer pour faire un trou.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-03/Y8Cimage.png)
Création manche couteau (qui est identique pour la créations des autres couverts) on insère un cylindre dans le manche puis on perce.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-03/u0Fimage.png)
Création des dents du couteau grâce à l'outil de dessin.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-03/F3timage.png)
Par la suite nous avons déplacer les couverts et créer l'anneau afin de les relier.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-03/1d9image.png)
Puis nous avons télécharger le fichier dans Prusa... afin d'imprimer notre objet.
À la fin de l'impression nous avons récupérer notre object. En détachant le socle les couverts était réussi cependant l'anneau c'est cassé.
**IDÉE DE PROJET FINAL :**
Une version simplifiée du projet de la \*\*mini serre automatisée\*\* pourrait être de créer un \*\*système d’irrigation automatique à base de capteur d'humidité\*\*, sans intégrer d'écran LCD ni autres éléments complexes.
Voici une version plus simple :
\### \*\*Projet : Système d'irrigation automatique simplifié\*\*
\- \*\*Définition du projet :\*\* Créer un système d’arrosage automatique pour une plante en utilisant un capteur d'humidité du sol. Lorsqu'un seuil d'humidité bas est détecté, une pompe se met en marche pour arroser la plante.
\- \*\*Technologies :\*\*
\- \*\*Arduino\*\* pour le contrôle du capteur d'humidité et de la pompe.
\- \*\*3D printing\*\* pour fabriquer un petit boîtier pour le capteur et la pompe, ou pour une base de support si nécessaire.
\- \*\*Fonctionnalité principale :\*\*
\- Le capteur mesure l'humidité du sol.
\- Si l'humidité est trop basse (sol sec), le système déclenche l’arrosage via une petite pompe.
\- Une fois l'humidité du sol suffisante, l’arrosage s'arrête automatiquement.
\- \*\*Idée d’amélioration simplifiée :\*\*
\- Remplacer l'écran LCD par une simple LED qui s'allume lorsque le système arrose, indiquant que l'irrigation est en cours.
\### \*\*Plan simplifié de réalisation :\*\*
1\. \*\*Capteur d'humidité\*\* : Utilisation d'un capteur d'humidité de sol basique, facile à intégrer avec Arduino.
2\. \*\*Pompe à eau\*\* : Une petite pompe submersible alimentée par Arduino ou via une source externe.
3\. \*\*Arduino\*\* : Programmation de l’Arduino pour surveiller en continu le niveau d’humidité et contrôler la pompe d’arrosage.
4\. \*\*Boîtier imprimé en 3D\*\* : Un boîtier simple pour protéger les composants électroniques et fixer le capteur dans le sol.
\### \*\*Liste du matériel :\*\*
\- Arduino Uno ou Nano
\- Capteur d'humidité de sol
\- Petite pompe à eau 5V
\- Transistor ou relais pour contrôler la pompe
\- LED pour signaler l’arrosage
\- Tubes pour l'irrigation (si nécessaire)
\- Imprimante 3D et filament pour fabriquer un support
\### \*\*Avantages :\*\*
\- Facilité d’assemblage et de programmation pour des débutants.
\- Moins de composants à gérer (pas d'écran LCD ou de capteurs supplémentaires).
\- Moins de risques d’échec et moins de temps nécessaire.
Qu’en penses-tu ? Cette version te semble-t-elle plus accessible tout en répondant à ton besoin ?
# MU5U001 Arrosoir électronique
# MU5EEH12 AKLI & WANG __Project__ _Sésame
**Informations**
- Membre du projet : AKLI Ilyes, WANG Zihan
- EMAIL : ilyes.akli@etu.sorbonne-universite.fr
- CURSUS : 2ème année Master en IPS (SMR)
- UE : MU5EEH12 : Designing
- Chargé d'UE : Mr Fabien VERITE
- Date de début : 16-09-2024
**Contexte**
Notre projet vise à faciliter l'ouverture des portes pour les personnes à mobilité réduite, pour qui cette tâche peut représenter un défi quotidien. Nous sommes conscients qu'un dispositif de ce type peut sembler ambitieux, mais nous croyons que chacun devrait pouvoir ouvrir les portes de sa maison facilement, sans effort excessif.
L'objectif de ce projet est de concevoir un appareil simple, abordable et accessible à tous. Ce dispositif pourra être installé rapidement, sans nécessiter de modifications majeures à la porte ou à ses mécanismes d'ouverture, et sans perturber son utilisation normale.
**Matérielles**
- ESP32 CAM
- Arduino Uno (Pour les tests)
- ESP32 (Pour l'utilisation finale)
- 2 moteurs ft5330m
- Support imprimer en 3D par une Prusa et avec un filament en PLA
**Vidéo temporaire**
[Vidéo de démonstration:](https://youtu.be/f4OBBeXH0x4)
[https://youtu.be/0S3bM0M3y90](https://youtu.be/f4OBBeXH0x4)
**CAD**
Le design de notre outil permet de répondre aux besoins du processus d’ouverture : tirer la poignée, la faire descendre de 3 à 4 cm, puis pousser la porte. Pour cela, nous avons reparti l’outil en plusieurs sous-pièces.
**Platine** **moteur**
Ces pièces permettent de supporter deux moteurs
**Platine moteur Tire poignée**
Cette pièce est créée selon le schéma ci-dessous, avec une épaisseur de 0,5 cm.
**Platine moteur Pousse porte**
Cette pièce est conçue pour pousser la porte en translation. Elle est également imprimée en PLA.
**Support ESP-CAM**
Cette pièce a pour objectifs de :
\- supporter l’ESP32-CAM,
\- verrouiller les platines dans le boîtier,
\- fermer le boîtier.
Les dimensions sont présentées dans les figures suivantes.
**Came**
La fabrication de la came nécessite l’utilisation d’inserts filetés pour PLA afin de stabiliser sa rotation et d’éliminer les vibrations dues aux jeux mécaniques.
**Boîtier**
Pièce maîtresse de ce projet, le boîtier permet de regrouper tous les éléments. Il est conçu de manière symétrique pour permettre une utilisation avec des portes s’ouvrant à droite ou à gauche.
Un emplacement est laissé vide en bas du boîtier pour accueillir la batterie ainsi que le câblage.
**Contrôle**
La partie contrôle se divise en plusieurs étapes : la définition de la caméra, la transmission des informations entre l’ESP et le terminal, la détection de reconnaissance faciale sur le terminal et la définition du servomoteur.
Commençons par la définition de la caméra.
**ESP32-CAM : Acquisition de flux vidéo en temps réel**
L’ESP32-CAM est une carte de développement caméra de très petite taille, mesurant seulement 27 x 40,5 x 4,5 mm. Elle peut fonctionner de manière autonome en tant que système, avec un courant en mode veille profonde ne dépassant que 6 mA.
L’ESP32-CAM est largement utilisée dans divers développements pour l’Internet des objets (IoT). Elle convient parfaitement aux dispositifs intelligents domestiques, au contrôle sans fil industriel, à la surveillance sans fil, à la reconnaissance sans fil de QR codes, aux signaux de systèmes de localisation sans fil, ainsi qu’à d’autres applications IoT. Elle constitue une solution idéale pour les projets IoT.
Pour compléter l’ESP32-CAM, le module ESP32 AI Thinker est utilisé, permettant une gravure facile via une connexion USB. Cela simplifie grandement le développement pratique.
**Configuration de l’ESP32-CAM avec Arduino IDE**
Il existe de nombreuses méthodes pour compiler l’ESP32-CAM, mais l’utilisation d’Arduino IDE est la plus simple et sera expliquée ici.
Tout d’abord, étant donné qu’Arduino IDE ne prend pas en charge nativement les cartes ESP32, il est nécessaire d’installer manuellement les configurations nécessaires. Heureusement, un référentiel contenant les bibliothèques ESP32 est déjà disponible. Il suffit d’ajouter le lien suivant dans les paramètres d’URL de gestionnaire de cartes supplémentaires :
[https://dl.espressif.com/dl/package\_esp32\_index.json](https://dl.espressif.com/dl/package_esp32_index.json)
Ensuite, accédez à Outils > Type de carte > Gestionnaire de cartes, recherchez ESP32 et sélectionnez ESP32 Wrover Module.
Une fois cette étape terminée, vous constaterez qu’une nouvelle catégorie ESP32 apparaît dans le menu des exemples : Fichier > Exemples > ESP32 > Camera > CameraWebServer. En accédant à cet exemple, on peut charger le code source et configurer les identifiants et mots de passe Wi-Fi nécessaires. Cela permettra à l’ESP32-CAM de transmettre un flux vidéo en temps réel à votre ordinateur.
Nous procédons ce code au téléversement sur l’ESP32-CAM. Si tout se passe bien, l’ESP32-CAM affichera une URL dans la console série de l’IDE.
Cette URL permettra d’accéder au flux vidéo ou aux données renvoyées par l’ESP32-CAM via un navigateur web.
**Automatisation du Stream et intégration des commandes HTTP**
Si nous ne modifions pas le code d’exemple, le résultat est comme illustré à la figure [26](file:///C:/Users/Ilakor/Downloads/vertopal.com_root.doc#fig%3Aimage14), où l’utilisateur doit manuellement cliquer sur “Start Stream” pour obtenir une surveillance en temps réel dans une zone spécifique de la page web. Cependant, cette méthode ne correspond pas à nos objectifs de conception, car elle ajoute une complexité inutile aux opérations manuelles, rendant difficile l’automatisation des tâches de surveillance en temps réel. De plus, la vidéo en streaming ne peut pas être directement transmise au module Python via Wi-Fi de manière optimale, ce qui entraîne un retard significatif pour le module de détection faciale. Pour résoudre ces problèmes, nous avons apporté les modifications suivantes au code d’exemple :
**Création d’une tâche Stream pour le déclenchement automatique**
Pour répondre aux exigences de réactivité et éviter les blocages dans le programme principal, nous avons intégré une tâche FreeRTOS dédiée dans le fichier .cpp, qui encapsule la fonction de gestion du flux vidéo et permet une transmission automatique du flux vidéo en la déclenchant automatiquement lors du démarrage du système. Cette tâche est définie comme suit:
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-05/qhLimage.png)
Ces modifications garantissent que la tâche est lancée immédiatement après l’initialisation du serveur HTTP, sans nécessiter d’intervention manuelle.
**Intégration de la commande d’ouverture dans le fichier principal .ino**
La gestion des commandes repose sur deux parties :
·*Dans le fichier .cpp* : La route HTTP /control est enregistrée pour associer les requêtes POST à la fonction control\_handler.
·*Dans le fichier .ino* : La fonction control\_handler implémente la logique d’ouverture de la porte.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-05/utsimage.png)
En combinant les fonctions définies dans le fichier .cpp et .ino, cette logique permet une gestion efficace des commandes d’ouverture, intégrant à la fois la réception des requêtes et l’exécution des actions correspondantes.
**Terminal : Détection faciale pour les vidéos transmises par ESP32**
**Aperçu du système de détection faciale**
Notre système de détection faciale est basé sur **DeepFace**, un framework Python léger conçu pour la reconnaissance faciale et l’analyse des attributs du visage (incluant l’âge, le sexe, les émotions et l’origine ethnique). DeepFace est un framework hybride qui intègre plusieurs modèles de pointe, notamment VGG-Face, *FaceNet*, *OpenFace*, *DeepFace*, *DeepID*, *ArcFace*, *Dlib*, *SFace* et *GhostFaceNet*.
D’après les résultats expérimentaux, les humains atteignent une précision de 97,53% dans les tâches de reconnaissance faciale, tandis que les modèles intégrés dans DeepFace ont déjà égalé ou dépassé ce niveau de précision. DeepFace fournit également des interfaces fonctionnelles pratiques qui permettent d’accomplir rapidement des tâches complexes de reconnaissance faciale.
Lien officiel : [https://github.com/serengil/deepface](https://github.com/serengil/deepface)
Le processus de reconnaissance faciale dans DeepFace peut être résumé en plusieurs étapes : détection, alignement, extraction de caractéristiques et comparaison. Nous pouvons explorer les principes fondamentaux de sa détection faciale pour mieux comprendre son fonctionnement.
·**Détection faciale :** DeepFace utilise des algorithmes de détection pour localiser les visages dans une image ou un flux vidéo. Si une image contient ![]()visages, alors chaque visage est extrait comme une région ![]()définie par ses coordonnées de boîte englobante :
![]()·**Comparaison de caractéristiques :** Une fois les caractéristiques extraites sous forme de vecteurs d’encodage ![](), la similarité entre deux visages est mesurée à l’aide de la distance euclidienne :
![]()où ![]()est la distance entre les vecteurs de caractéristiques ![]()et ![](). Si ![](), alors les deux visages sont considérés comme correspondants, avec ![]()comme seuil prédéfini.
Ces formules permettent d’expliquer deux étapes cruciales de DeepFace : la détection des visages et la mesure de leur similarité.
**Création du jeu de données**
Dans notre système, nous utilisons un jeu de données personnalisé, qui contient plusieurs photos de visages destinées aux tâches de comparaison et de reconnaissance faciale. Conformément à la documentation officielle de DeepFace, il suffit d’ajouter les photos des visages des personnes cibles dans le jeu de données et d’utiliser les modèles pré-entraînés fournis par DeepFace pour répondre à nos besoins de reconnaissance.
Comme le montre la figure 18, le jeu de données stocke des photos de plusieurs personnes, chaque photo étant nommée selon l’identité correspondante (par exemple, trump1, trump2, trump3). Nous créons un dictionnaire des permissions pour inclure les identités autorisées à ouvrir la porte. Par exemple, si Trump et moi-même avons la permission d’ouvrir la porte, nous ajoutons les noms de fichiers correspondants (comme trump1, trump2, trump3) au dictionnaire.
Lors de l’exécution, le modèle de détection de DeepFace compare les images d’entrée avec les identités dans le jeu de données, en fonction du dictionnaire des permissions. Si le modèle détecte une identité autorisée, celle-ci est ajoutée à une liste renvoyée par le système. En vérifiant si cette liste contient une identité autorisée, le système décide s’il doit envoyer une commande d’ouverture à l’ESP32.
**Description de l’implémentation globale**
Comme décrit précédemment, nous disposons d’un outil de détection faciale basé sur DeepFace, d’un jeu de données personnalisé et des images transmises par ESP32. En combinant ces éléments, nous pouvons mettre en œuvre notre fonction de détection faciale pour identifier des visages autorisés et envoyer des commandes à ESP32.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-05/zwuimage.png)
Cette implémentation permet de combiner les capacités de détection faciale de DeepFace avec la transmission vidéo de l’ESP32. Ce système garantit une intégration fluide entre le terminal Python et l’ESP32, offrant une reconnaissance faciale rapide et précise, tout en automatisant les commandes pour améliorer l’expérience utilisateur.
**Conclusion**
Dans le cadre de ce projet, nous avons réalisé un dispositif d’ouverture de porte automatisé à très faible coût. Les deux parties essentielles de ce dispositif – la conception assistée par ordinateur (CAO) et le contrôle automatisé – permettent toutes deux une reproduction à coût nul et une fabrication à faible coût. Cela offre une nouvelle solution, économique et facilement déployable, pour transformer une porte manuelle classique en porte automatique.
Nous sommes particulièrement heureux que notre conception puisse venir en aide aux personnes rencontrant des difficultés à ouvrir les portes. Ce projet a également été pour nous l’occasion de nous initier à la modélisation CAO, et de combiner avec succès la conception assistée par ordinateur, le développement matériel, l’apprentissage profond, ainsi que la configuration de la transmission WIFI entre le matériel et le terminal. Nous avons ainsi pu mettre en pratique les connaissances acquises depuis notre licence dans un projet concret.
Nous tenons à remercier l’Université Sorbonne pour les ressources mises à notre disposition, ainsi que Monsieur Fabien Vérité pour son accompagnement et ses conseils tout au long du projet. Nous lui souhaitons une brillante carrière académique et espérons que notre avenir professionnel sera tout aussi riche en réussites.
# MU5U001 Résistivimétre
# Wiki - Projet ProAdapt
### Informations
• Prénom et nom :
- Armand LELONG
- Grégoire MAHON
- Sylvain PLAZE
- Chahine Boukhenaissi-Lahreche
- Mohamed ZAIDI
- Jonathan Queyroi
• Adresse mail :
-
- Gregoire.mahon@etu.sorbonne-universite.fr
-
-
-
- Jonathan.Queyroi@etu.sorbonne-universite.fr
• Cursus : Polytech Sorbonne - Ingénierie électronique et informatique - Informatique Industrielle
• Date de début : Septembre 2024
• Date de fin estimée : Janvier 2025
Contexte
Les athlètes amputés rencontrent des difficultés spécifiques liées à l’utilisation des prothèses : optimisation de la technique de course, prévention des blessures et amélioration du confort. Les solutions actuelles manquent de systèmes de feedback précis.
ProAdapt vise à combler cette lacune en développant un kit de capteurs avancé et des interfaces utilisateur dédiées, permettant une analyse approfondie des performances sportives.
Objectifs
1\. Développer un kit de capteurs modulaire compatible avec toutes les prothèses de jambe.
2\. Collecter et analyser des données en temps réel sur la dynamique de course, la température, et les forces exercées.
3\. Créer une application mobile conviviale pour les athlètes et une interface dédiée pour les médecins.
4\. Garantir une autonomie de 8 heures pour des entraînements prolongés.
5\. Assurer la robustesse et la résistance à l’eau et à la poussière (IP67).
Matériel utilisé
• Capteurs :
• Capteur de flexion FS2L095 (x2)
• Module MPU-6050 (x4)
• Capteur GPS GOKU GM10 Nano V3
• Électronique :
• ESP32 pour Bluetooth et Wi-Fi
• Batterie LiPo 4000 mAh
• Boîtier : Étanche, compact, et résistant aux chocs
• Logiciels : IDE Arduino, outils de développement mobile (Android/iOS)
Machines utilisées
• Imprimante 3D (prototypage du boîtier)
• Station de soudure
• Ordinateurs pour développement logiciel
# MU5EEH12 Designing - BAYARD, FERNANDEZ, GARRIDO, SI-FODIL
#### **Project Information**
- **Project Members**: Noah Bayard, Soumeya Si-Fodil, Iñigo Garrido, Sandra Fernandez
- **Email**: , ,
- **Program**: M2 in Engineering for Health (MSR)
- **Course**: MU5EEH12 - Designing
- **Course Supervisor**: Mr. Fabien VERITE
- **Start Date**: 16-09-2024
#### **Context**
Our project focuses on improving accessibility for blind and visually impaired individuals, allowing them to interact with smartphones more intuitively and efficiently while on the go. For these users, navigating through apps or accessing information often requires holding the phone, which may not always be practical or safe.
The goal of this project is to design a capacitive touchscreen belt that enables blind users to control their phones without needing to take them out of their pockets. This device will be compact, affordable, and user-friendly. It will integrate seamlessly with existing assistive technologies like VoiceOver, providing an enhanced level of autonomy and convenience.
#### **Materials**
- **Capacitive Touch Panel**: For gesture recognition.
- **Arduino Nano**: For trackpad PS/2 communication..
- **ESP32**: For BLE keyboard HDI capabilities.
- **3D-Printed Components**: Supports and housing printed with a 3D printer using PLA filament.
- **Other Components**:
- Pushbuttons for other iPhone functions and additional features.
#### **Video Demonstration**
*Coming soon.*
#### **Arduino Code**
*Coming soon.*
#### **BLE Mouse Code**
*Coming soon.*
#### **3D Model**
*Coming soon.*
#### **Assembly Instructions**
*Coming soon.*
#### **Additional Notes**
We are developing this project to promote inclusivity and accessibility for blind users. The final device will provide an intuitive, hands-free interaction method for smartphones, ensuring that accessibility is affordable and widely available.
We are excited to collaborate with the fabrication lab to bring this concept to life and make a meaningful difference in assistive technology.
# UE EPUR8DPR
### Réalisation de plaque pour l'insertion d'une charnière
Nous avons dû découper une plaque en PMMA 3mm car il nous fallait une structure en plastique semi rigide.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/photo-2025-02-05-14-37-19.jpg)
Nous avons utilisé la Trotec Speedy 360 avec tous les tutos disponibles sur la page d'accueil du Fablab.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/img-3787.jpg)
On a également ajouter 4 fixations pour visser cette plaque sur nos charnières.[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-02/plaque-troue.jpg)
# ROB4 Projet Industriel EPU-R7-8-DPR
## Réalisation d'un plateau tournant motorisé
Conception d'un plateau qui tourne à l’aide d’un moteur SPG30-20K Cytron DC Geared Motor.
*Figure 1 : Vu en coupe du présentoir motorisé*
#### Palonnier du moteur
Afin de mettre en mouvement le plateau supérieur, voici le palonnier que nous avons modélisé pour notre moteur. Ce palonnier sera fixé sur la partie tournante du présentoir et l'arbre moteur qui s’insère dans ce palonnier mettra en mouvement donc notre présentoir.
*Figure 5 : Palonnier du moteur*
*Figure 5 : Palonnier du moteur*
#### Support Moteur
Tandis que le palonnier ci-dessus sera fixé sur la partie supérieure (tournante) du présentoir, le moteur lui sera vissé dans ce support moteur et ce support moteur sera fixé sur la partie inférieure (fixe) du présentoir.
*Figure 6 : Support du moteur Cytron DC Geared Motor SPG30-20K*
## Réalisation d'un support code
*Figure 7: Support 1 et 2*
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-04/apBimage.png)
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-04/aQuimage.png)
# Projet élaboration de microsupercondensateur par découpeuse laser
Durant mon projet de thèse, j'étudie les propriétés électrochimiques de différents matériaux à base de graphène. Lorsque j'ai un bon candidat qui permet de stocker beaucoup d'énergie j'élabore un microsupercondensatieur grâce à la découpeuse laser.
[](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2025-03/img-2766.jpg)
# Recherche de paramètres laser DYCEM
#### Informations
- Louis Le Berre
- louis.le\_berre@etu.sorbonne-universite.fr
- ISIR
- 19/03/2025 - 24/03/2025
#### Contexte
#### Objectifs
Trouver les paramètres à utiliser pour la trotec laser 360 pour découper et graver du Dycem.
*Ajouter au moins une image de votre projet*
#### Matériel
- Du Dycem
#### Machines utilisées
Trotec Speedy 360
#### Journal de bord
##### 19/03/2025
Découpe : C02 1000Hz 1 Passage
- P : 80% , V : 1.2% --> Découpe ok mais bords bien brûlés, et dessous attaqué
- P : 50% , V : 1.2% --> Découpe ok mais bords un peu brûlés, et dessous attaqué
- P : 30% , V : 1.2% --> Découpe vraiment bien brûlures très faible
- P : 15% , V : 1.2% --> Découpe vraiment bien, bords tout tout petit peu brûlés
- P : 5% , V : 1.2% --> Pas de découpe
- P : 10% , V : 1.2% --> Presque découpé, détaché à la main
- P : 12.5% , V : 1.2% --> Découpe un peu faible
- Privilégier le 15%
Gravure (noir, 100%) : C02 1000Hz 1 Passage DPI 500
- P : 50%, V : 100% --> Surface bleue enlevée, matériau coeur un peu brûlé
- P : 25%, V : 100% --> Surface bleue enlevée, matériau coeur un peu moins brûlé
- P : 12,5%, V : 100% ---> Surface à peine affectée, presque invisible
- P : 20%, V : 100% ---> Idem
- P : 23%, V : 100% ---> Surface bien enlevée, un peu de brûlure
- Essai sur plus grande surface : concluant
##### 20/03/2025 - Essai de diminution de puissance avec plusieurs passages pour réduire le côté brûlé
Gravure (noir, 100%) : C02 1000Hz DPI 500, V : 100%
- P : 20%, 4 passages : morceaux épars un peu enlevés au bout de 4 passages
- P : 22%, 4 passages : surface enlevée dès le premier passage, quelques petits restes, les autres passages brûlent un peu
- P : 21%, 4 passages : surface bien enlevée après 3 passages mais toujours surface finale plus brûlée que ce que m'a donné mon tuteur
- P : 20%, V : 50% : brûle dès le premier passage
- P : 20%, V : 90% : il faut 2 passages pour une surface presque complétement enlevée et très légèrement brûlée
- Le problème c'est que plusieurs passages ça fait un truc pas homogène
- P : 21,5 V : 100% : le problème c'est que la surface n'est pas enlevée de manière homogène, mais là où elle est enlevée ça reste plus brûlé que le témoin que je cherche à reproduire. On peut essayer d'aller vraiment gratter très doucement
- P : 10%, V : 50% : Rien en 2 passages
- P : 15%, V : 50% : Surface enlevée de manière homogène (très joli, le moins brûlé jusqu'ici) en 1 passage
- P : 12,5%, V : 50%, 5 passages : Vraiment plusieurs passages pour la gravure c'est pas la peine, c'est beaucoup trop inhomogène (réserver pour la découpe où la on s'en moque et ça devrait limiter les brûlures au point de détahcement). Après le delta de puissance entre rien et surface brûlée et très très faible. Bon résultat en diminuant puissance et vitesse, à chercher de ce côté
- P : 7%, V : 25% : Ca manque d'un tout petit peu de puissane, il reste des fines traces de dycem en surface
- P : 7,5%, V : 25% : Dycem enlevé de manière homogène, j'ai bien l'impression que réduire puissance et vitesse donne au final moins de brûlures
- P : 4%, V : 15% : pas suffisant
- P : 7,25%, V : 25 : surface enlevée en une fois, bien homogène, couleur presque semblable à l'échantillon témoin
Découpe :
- P : 5%, V : 1,2%, 5 passages : bords intérieurs pas trop brûlés
- P : 3%, V : 1,2%, 5 passages : pas totalement détaché birds intérieur plus brûlés que précédemment
- P : 4%, V : 1,2% : 3 passages : pas totalement détaché
- P : 4,5%, V : 1,2% : 3 passages : détaché à la main. Le premier, quand ça se coupe tout seul sans avoir à détacher c'est le plus propre. Ou alors c'est le fait que le laser passe sur un rond déjà découpé, ça nettoie un peu
En faisant une membrane test avec mes nouveaux paramètres, j'obtiens finalement quelque chose de très similaire à ce que j'avais obtenu hier ---> pas tant de différence que ça en fait en diminuant puissance et vitesse (même si le résultat de gravure obtenu pour la membrane a l'air bien plus brûlé que ce que j'avais obtenu avec un rectangle test). Le problème est que je n'arrive pas à un moment où j'obtiens le dycem enlevé de manière homogène ET une attaque suffisamment faible de la couche du dessus
\--- > le DPI pourra peut-être m'aider sur la gravure, sinon c'est le type de laser et son énergie qui sont la cause de la différence.
Les paramètres de découpe d'hier sont bien, les paramètres de gravure permettent d'obtenir une surface un peu brunie plutôt que gris uniforme comme je cherche à avoir
##### 24/03/2025 - Etude d'une anomalie
Il m'est apparu que, même après avoir trouvé mes réglages de gravure, les résultats n'étaient pas similaires selon les fois où je les appliquais. J'ai testé différentes configurations pour voir ce qui pouvait causer ces différences. Deux choses ont été notées :
1\) Comme vu précédemment durant la rechercher des paramètres, le dycem est un matériau capricieux (car complexe je suppose) qui accepte difficilement des paramètres constants pour un résultat toujours similaire. De plus, il semble qu'une différence minime amène à la disparition ou à la conservation de la couche colorée du dycem lors de la gravue. Je préconise donc de toujours choisir une puissance légèrement supérieure à celle "limite" pour être sûr que la gravure soit bonne, sans résidus de matière anti-dérapante
2\) Le dycem a un recto et un verso qui ne se comporte pas exactement de la même manière, le verso ayant plus tendance à donner une couleur claire (et donc à moins brûler) que le recto
##### Conclusion :
**Découpe : P : 4,5%, V : 1,2%, 5 passages**
**Gravure : P : 25%, V : 100%, 1 passage**
**Attention, différence de gravure selon recto/verso**
**26/05/2025**
Nouveaux tests après avoir constaté que les anciens paramètres ne marchaient pus (changement de buse ?). Permet de tester l'impact du DPI qui semblait être très important sur une autre découpeuse laser que j'ai pu utiliser.
AVec 1000 de DPI, en 1 passage, le mieux est :
Gravure : P:33%, V : 100% (30% ça grave pas, mais là ça frippe quand même, ça brûle un peu trop)
Découpe : P : 20%, V : 1,2%
MAis 1000 DPI
# LU1SXARE, ARE SCIMAG, les mélanges
LU1SXARE SCIMAG « LES MÉLANGES »
Julie RIEHL (julie.riehl@etu.sorbonne-universite.fr)
Ken Duy BUI-THANH-TU (ken\_duy.bui-thanh-tu@etu.sorbonne-universite.fr)
Date début : 26/03/2025
Date de fin :
Objectifs : Réaliser un rectangle d’illusion optique dans le cadre de l’ARE Magie
Contexte : ARE SCIMAG —> Magie
Matériaux/outils/machines : Découpeuse laser sur MDF 3 mm
Construction :
JOURNAL DE BORD :
26/03/2025 :