# Dila TERZI

M1 Management de l'Innovation - Dila TEZI - <Dila.Terzi@etu.sorbonne-universite.fr>

##### <span style="text-decoration: underline;">**Séance 16/12/2025 :** </span>

### <span style="text-decoration: underline;">**Exercice 1 :**</span> **Découverte de l'impression 3D à partir d'un modèle existant - Figurine T-rex**

##### **Objectifs :** 

- Se familiariser avec les principes de base de l’impression 3D à partir d’un fichier numérique déjà conçu
- Identifier le rôle du logiciel de slicing et analyser l’impact des principaux paramètres sur le résultat final
- Mettre en perspective une pièce imprimée en 3D avec un objet issu d’un procédé de fabrication industriel ou standardisé

##### **Présentation du projet :** 

Dans le cadre de ce projet, l’objectif principal était de se familiariser avec le processus d’impression 3D à partir d’un modèle déjà existant, en utilisant le logiciel **<span class="hover:entity-accent entity-underline inline cursor-pointer align-baseline"><span class="whitespace-normal">PrusaSlicer</span></span>**.

Contrairement à un objet industriel standardisé, j’ai choisi d’imprimer une **figurine de T-rex**, un modèle plus organique et complexe, afin d’observer le comportement de l’impression 3D sur des formes courbes, des détails fins et des porte-à-faux (bras, tête, queue).

Ce choix permettait de mettre en évidence les limites et contraintes de l’impression FDM, notamment en termes de précision géométrique, de stabilité et de gestion des supports.

##### **Matériel et logiciel utilisés :** 

- Logiciel de slicing : PrusaSlicer
- Imprimante 3D : Original Prusa MK4S
- Technologie : FFF
- Matériel : PLA

##### **Processus d'impression :**

Le modèle de la figurine T-rex a été importé dans PrusaSlicer puis préparé pour l’impression.

[![Görüntü 15.01.2026 16.59.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/goruntu-15-01-2026-16-59.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/goruntu-15-01-2026-16-59.jpeg)

[![Görüntü 15.01.2026 16.59 (1).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/goruntu-15-01-2026-16-59-1.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/goruntu-15-01-2026-16-59-1.jpeg)

[![Görüntü 15.01.2026 16.59 (2).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/goruntu-15-01-2026-16-59-2.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/goruntu-15-01-2026-16-59-2.jpeg)

Les principaux paramètres utilisés sont :

- **Température de la buse** : 200 °C
- **Température du plateau** : 60 °C
- **Taux de remplissage (infill)** : 20 %
- **Supports** : supports uniquement sur le plateau
- **Temps d’impression estimé** : environ 36 minutes

Une fois l’impression terminée, la pièce a été retirée du plateau puis nettoyée, notamment par l’élimination des supports générés sous certaines parties du modèle.

##### **Résultats et observations :**  


Lors de la première tentative d’impression, les paramètres n’étaient pas adaptés au filament de couleur choisi. La température de la buse et la vitesse d’impression étaient trop élevées, ce qui a provoqué une mauvaise extrusion et un collage excessif du filament. L’impression a donc été arrêtée.

Une seconde impression a ensuite été réalisée après ajustement des paramètres, permettant une extrusion plus régulière et une meilleure qualité globale de la pièce.

La figurine obtenue est globalement fidèle au modèle numérique. Toutefois, un léger défaut est observable à la base de l’objet, correspondant à un décalage de couches (*layer shift*), probablement dû à une collision liée à un léger soulèvement de la pièce pendant l’impression.

##### **Conclusion :**

Ce projet m’a permis de découvrir le fonctionnement de l’impression 3D et l’importance des paramètres d’impression.  
L’impression du T-rex montre que, malgré sa capacité à produire des formes complexes, cette technologie reste sensible à certains défauts.  
Elle constitue néanmoins un outil efficace pour le prototypage et la fabrication personnalisée.

##### **Objet terminé :**

**[![WhatsApp Image 2026-01-15 at 17.33.12.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/scaled-1680-/whatsapp-image-2026-01-15-at-17-33-12.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-01/whatsapp-image-2026-01-15-at-17-33-12.jpeg)**

### <span style="text-decoration: underline;">**Exercice 2 :**</span> **Création d’un objet en mobilisant un maximum de fonctions OpenSCAD**

##### **Bille dans une cage – Objet print-in-place**

##### **Objectifs :** 

- Se familiariser avec les principales fonctions d’OpenSCAD à travers la conception d’un objet paramétrique.
- Combiner un maximum d’opérations booléennes et de transformations géométriques.
- Concevoir un objet *print-in-place* intégrant un élément mobile.
- Maîtriser la notion de jeu mécanique (*clearance*) pour garantir la mobilité après impression.
- Comprendre l’impact des paramètres d’impression sur la qualité finale.

##### **Contexte du projet :**

Pour cet exercice, j’ai conçu une **bille mobile enfermée dans une cage cylindrique**, imprimée en une seule fois sans assemblage ultérieur (*print-in-place*).

L’objet est composé de :

- Une cage cylindrique externe
- Une cavité intérieure
- Deux ouvertures latérales opposées
- Une bille centrale libre de mouvement

Le défi principal était de garantir un espace suffisant entre la bille et la cage afin que la bille puisse bouger après impression, tout en maintenant une structure stable.

Le paramètre clé du projet est la variable : **clearance = 0.45 mm. Ce jeu mécanique permet d’éviter la fusion des deux éléments pendant l’impression.**

##### **Fonctions OpenSCAD utilisées**

Le projet mobilise plusieurs fonctions avancées :

- `cylinder()` → création du corps extérieur et de la cavité
- `sphere()` → génération de la bille interne
- `difference()` → création de la cage creuse
- `translate()` → positionnement des ouvertures
- `rotate()` → symétrie des ouvertures
- `for()` → génération automatique répétée
- `module()` → structuration du code
- `$fn = 80` → amélioration de la résolution des surfaces courbes

Le diamètre extérieur de la cage est calculé automatiquement : **cage\_outer\_d = ball\_d + 2\*(wall + clearance); Cette approche paramétrique permet d’adapter facilement les dimensions si la précision de l’imprimante change.**

##### **Paramètres principaux**

- Diamètre bille : 16 mm
- Épaisseur paroi : 2.2 mm
- Clearance : 0.45 mm
- Largeur ouvertures : 6 mm
- Hauteur ouvertures : 20 mm
- Diamètre total : ≈ 21.3 mm

##### **Matériaux / Outils / Logiciels**

- Logiciel de modélisation : OpenSCAD
- Logiciel de slicing : PrusaSlicer
- Imprimante : Original Prusa MK4S
- Filament : PLA 1.75 mm (rouge)
- Température buse : 230 °C
- Température plateau : 60 °C
- Infill : 20 %
- Supports : build plate only
- Temps estimé : 22 minutes
- Filament utilisé : 1.65 m

##### **Étapes de fabrication**

- Modélisation paramétrique sous OpenSCAD.
- Exportation du fichier en STL.
- Importation dans PrusaSlicer.
- Réglage des paramètres d’impression.
- Génération du G-code.
- Lancement de l’impression.
- Inspection et analyse du résultat.

##### **Processus d'impression :**

**[![Görüntü 19.02.2026 14.00.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/goruntu-19-02-2026-14-00.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/goruntu-19-02-2026-14-00.jpeg)**

**[![Görüntü 19.02.2026 14.01.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/goruntu-19-02-2026-14-01.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/goruntu-19-02-2026-14-01.jpeg)**

**[![Görüntü 19.02.2026 14.01 (2).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/goruntu-19-02-2026-14-01-2.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/goruntu-19-02-2026-14-01-2.jpeg)**

**[![Görüntü 19.02.2026 14.05.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/goruntu-19-02-2026-14-05.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/goruntu-19-02-2026-14-05.jpeg)**

**[![Görüntü 19.02.2026 14.05 (1).jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/goruntu-19-02-2026-14-05-1.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/goruntu-19-02-2026-14-05-1.jpeg)**

**[![Görüntü 19.02.2026 14.06.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/goruntu-19-02-2026-14-06.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/goruntu-19-02-2026-14-06.jpeg)**

##### **Problèmes rencontrés lors de l’impression**

Lors de l’impression réelle, la pièce a commencé à **se déplacer légèrement sur le plateau** au cours du processus. Cela a provoqué un **décalage des couches (layer shifting)** visible sur la partie supérieure.

##### **Causes probables :**

- Absence de brim
- Surface d’adhérence réduite (base ≈ 21 mm)
- Vibrations dues aux mouvements rapides de la tête
- Contraintes mécaniques lors de l’impression des ouvertures latérales (bridging)
- Température légèrement élevée pour du PLA

La bille interne présente également une surface irrégulière. Cela s’explique par le fait que certaines couches sont imprimées en suspension partielle, ce qui peut provoquer un affaissement si le refroidissement ou la vitesse ne sont pas optimaux.

L’accumulation de filament sur le bord supérieur suggère également un léger déplacement progressif de la pièce pendant l’impression.

##### **Améliorations envisagées**

Pour optimiser une future impression :

- Ajouter un brim pour améliorer l’adhérence
- Réduire légèrement la vitesse d’impression
- Nettoyer soigneusement le plateau PEI
- Tester une température de buse plus basse (220–225 °C)
- Optimiser le refroidissement pour le bridging

##### **Conclusion**

Ce projet m’a permis de mobiliser un grand nombre de fonctions OpenSCAD et d’approfondir la conception paramétrique d’un objet print-in-place intégrant un mécanisme mobile.

L’expérience d’impression, bien que partiellement imparfaite, a été particulièrement instructive. Elle m’a permis de comprendre l’interaction directe entre la conception numérique et les contraintes physiques de fabrication additive.

Ce travail met en évidence l’importance du paramétrage, du jeu mécanique et des réglages d’impression dans la réussite d’un objet fonctionnel imprimé en 3D.

##### **Objet terminé :**

**[![IMG_0537.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-0537.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-0537.jpeg)**

**[![IMG_0533.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-0533.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-0533.jpeg)**

**[![IMG_0531.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-0531.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-0531.jpeg)**

### <span style="text-decoration: underline;">**GROUPE pour Arduino:**</span> **TERZI Dila, AKSU Dilara, OLIVA MENDEZ Cesar Giovanni**

### <span style="text-decoration: underline;">**Exercice 3 :**</span> **Clignotement de deux LEDs avec Arduino**

##### **Contexte**

Cette activité avait pour objectif de découvrir la programmation Arduino à travers la réalisation d’un montage électronique simple.  
Avant toute manipulation réelle, une phase de simulation a été effectuée sur TinkerCAD afin de vérifier la cohérence du câblage et le comportement logique du circuit.

Cette démarche permet :

- de tester le fonctionnement du programme,
- de limiter les erreurs de connexion,
- d’éviter d’endommager les composants.

##### **Objectif du premier exercice**

Le but du premier exercice était de faire clignoter deux LEDs simultanément selon un intervalle de temps défini.

Les deux LEDs doivent :

- s’allumer en même temps,
- rester allumées pendant 1 seconde,
- puis s’éteindre pendant 1 seconde,
- et répéter ce cycle en continu.

##### **Matériel utilisé**

- Carte Arduino Uno
- 2 LEDs
- 2 résistances de 220 Ω
- Breadboard
- Fils de connexion
- Logiciel Arduino IDE
- Simulateur TinkerCAD

##### **Montage du circuit**

##### ***Étape 1 – Câblage***

La borne GND de la carte Arduino est reliée à la ligne négative de la breadboard.

Pour chaque LED :

- la patte courte (cathode) est connectée à la masse (GND),
- la patte longue (anode) est reliée à une résistance de 220 Ω,
- l’autre extrémité de la résistance est connectée à la broche numérique 13.

Les résistances permettent de limiter le courant traversant les LEDs afin de protéger les composants.

[![Görüntü.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/goruntu.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/goruntu.jpeg)

##### ***Étape 2 – Programmation***

Le programme est structuré en deux parties :

- `setup()` : configuration initiale,
- `loop()` : exécution répétée.

Dans la fonction `setup()`, la broche 13 est configurée en sortie :

[![Ekran Resmi 2026-02-19 14.41.34.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/ekran-resmi-2026-02-19-14-41-34.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/ekran-resmi-2026-02-19-14-41-34.png)

Dans la fonction `loop()`, la LED est activée puis désactivée avec un intervalle d’une seconde :

[![Ekran Resmi 2026-02-19 14.42.03.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/ekran-resmi-2026-02-19-14-42-03.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/ekran-resmi-2026-02-19-14-42-03.png)

Le programme repose sur l’utilisation de la fonction `millis()`, qui retourne le nombre de millisecondes écoulées depuis le démarrage de la carte Arduino.

Deux temporisations indépendantes sont mises en place :

- une pour la LED 1 (2000 ms),
- une pour la LED 2 (3000 ms).

<div aria-label="Page Section Options" class="pointer-container" id="bkmrk--16" refs="pointer@pointer" tabindex="-1"><div class="pointer flex-container-row items-center justify-space-between p-s anim is-page-editable"><div class="flex-container-row items-center gap-s" refs="pointer@mode-section"><button class="text-button icon px-xs" title="Permalink mode, Press to show include tag"><svg class="svg-icon" data-icon="link" role="presentation" viewbox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"></svg></button><div class="input-group"> <button class="button outline icon" title="Copy Link" type="button"><svg class="svg-icon" data-icon="copy" role="presentation" viewbox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"></svg></button></div></div><svg class="svg-icon" data-icon="edit" role="presentation" viewbox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"></svg></div></div>Chaque LED change d’état (ON/OFF) lorsque l’intervalle correspondant est écoulé, sans interrompre l’exécution du programme principal.

[![Ekran Resmi 2026-02-19 14.43.25.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/ekran-resmi-2026-02-19-14-43-25.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/ekran-resmi-2026-02-19-14-43-25.png)

##### **Résultat obtenu**

Les deux LEDs s’allument et s’éteignent simultanément selon un cycle régulier d’une seconde.  
Le montage fonctionne correctement et permet de comprendre le principe de base du contrôle d’une sortie numérique avec Arduino.

### <span style="text-decoration: underline;">**Exercice 4 :**</span> **Clignotement de deux LEDs à fréquences différentes avec Arduino**

##### **Objectif**

L’objectif de cet exercice est de programmer une carte Arduino afin de faire clignoter deux LEDs de manière alternée, chacune avec un intervalle de temps défini.

Contrairement à l’exercice précédent où les LEDs fonctionnaient simultanément, ici elles doivent s’allumer à tour de rôle.

##### **Matériel utilisé**

- Carte Arduino Uno
- 2 LEDs
- 2 résistances de 220 Ω
- Breadboard
- Fils de connexion
- Logiciel Arduino IDE
- Simulateur TinkerCAD

##### **Montage du circuit**

##### ***Étape 1 – Câblage***

Le montage comprend deux LEDs reliées à deux sorties numériques différentes :

- LED 1 connectée à la broche 13
- LED 2 connectée à la broche 12

Chaque LED est montée en série avec une résistance de 220 Ω afin de limiter le courant et éviter toute détérioration.

Les cathodes des LEDs sont reliées à la masse (GND) de l’Arduino.

Ce choix de résistance est adapté à une alimentation de 5 V fournie par la carte Arduino.

[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/0GUimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/0GUimage.png)

##### ***Étape 2 – Programmation***

Le programme commence par la déclaration des broches utilisées :

[![Ekran Resmi 2026-02-19 14.50.54.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/ekran-resmi-2026-02-19-14-50-54.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/ekran-resmi-2026-02-19-14-50-54.png)

Dans la fonction `setup()`, les deux broches sont configurées en sortie :

[![Ekran Resmi 2026-02-19 14.51.21.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/ekran-resmi-2026-02-19-14-51-21.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/ekran-resmi-2026-02-19-14-51-21.png)

Dans la boucle principale, les LEDs s’allument alternativement :

[![Ekran Resmi 2026-02-19 14.51.45.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/ekran-resmi-2026-02-19-14-51-45.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/ekran-resmi-2026-02-19-14-51-45.png)

Code utilisé :

[![Ekran Resmi 2026-02-19 14.53.08.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/ekran-resmi-2026-02-19-14-53-08.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/ekran-resmi-2026-02-19-14-53-08.png)

##### **Résultat obtenu**

Les deux LEDs clignotent de manière alternée avec un intervalle régulier d’une seconde.  
Ce montage permet de comprendre la gestion de plusieurs sorties numériques indépendantes avec Arduino.

##### **Analyse**

Cet exercice met en évidence :

- la configuration de plusieurs broches en sortie,
- le contrôle indépendant de composants,
- l’utilisation de temporisations simples via `delay()`.

Il constitue une étape intermédiaire avant l’utilisation de méthodes plus avancées comme `millis()` pour éviter les blocages du programme.

### <span style="text-decoration: underline;">**Exercice 5 :**</span> **Capteur ultrasonique et signalisation par LEDs avec ARDUINO**

##### **Contexte**

Cette activité visait à exploiter un capteur pour contrôler des dispositifs de sortie (LEDs) en fonction des mesures obtenues. Dans le respect des méthodes de travail apprises en électronique, une phase de simulation sur TinkerCAD a été réalisée avant toute manipulation matérielle.

Cette démarche présente plusieurs avantages :

- vérifier la cohérence et la fiabilité du câblage du capteur ainsi que des LEDs ;
- analyser et corriger la logique du programme avant l’implémentation réelle ;
- limiter les risques d’erreur ou d’endommagement du matériel, notamment lorsqu’il est utilisé collectivement.

##### **Objectif**

L’objectif est d’utiliser un **capteur ultrasonique HC-SR04** pour mesurer la distance d’un objet, puis d’afficher une **signalisation visuelle** via **3 LEDs** selon des seuils de distance.  
Cet exercice permet aussi de comprendre comment on passe du **temps de propagation** de l’onde sonore à une **distance en cm**.

##### **Matériel**

- Arduino Uno
- Capteur ultrasonique **HC-SR04**
- 3 LEDs
- 3 résistances 220 Ω
- Breadboard + fils
- Arduino IDE
- (Optionnel) TinkerCAD

##### **Montage du circuit**

##### ***Étape 1 – Câblage***

**Capteur HC-SR04 :**

- VCC → **5V**
- GND → **GND**
- TRIG → **A0**
- ECHO → **A1**

**LEDs :**

- LED1 → broche **11** (avec résistance 220 Ω)
- LED2 → broche **12** (avec résistance 220 Ω)
- LED3 → broche **13** (avec résistance 220 Ω)
- Cathodes reliées au **GND**

[![image.png](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/zpKimage.png)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/zpKimage.png)

##### ***Étape 2 – Programmation***

Le programme :

<div aria-label="Page Section Options" class="pointer-container" id="bkmrk--25" refs="pointer@pointer" tabindex="-1"><div class="pointer flex-container-row items-center justify-space-between p-s anim is-page-editable"><div class="flex-container-row items-center gap-s" refs="pointer@mode-section"><button class="text-button icon px-xs" title="Permalink mode, Press to show include tag"><svg class="svg-icon" data-icon="link" role="presentation" viewbox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"></svg></button><div class="input-group"> <button class="button outline icon" title="Copy Link" type="button"><svg class="svg-icon" data-icon="copy" role="presentation" viewbox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"></svg></button></div></div><svg class="svg-icon" data-icon="edit" role="presentation" viewbox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"></svg></div></div>1. Génère une impulsion sur la broche trigger.
2. Mesure la durée du signal reçu sur la broche echo.
3. Convertit cette durée en distance (cm).
4. Active une LED différente selon la distance mesurée :
    
    
    - Distance &gt; 100 cm → LED 1
    - 50 cm &lt; Distance ≤ 100 cm → LED 2
    - 20 cm &lt; Distance ≤ 50 cm → LED 3
5. plus l’objet est proche, plus le temps de retour est court.  
    La distance est calculée par :
6. `distance_cm = (durée_en_microsecondes × 0,0343) / 2`  
    (division par 2 car l’onde fait **aller + retour**).

```
// Fonction permettant de mesurer la distance à l’aide d’un capteur ultrasonique
long readUltrasonicDistance(int triggerPin, int echoPin)
{
  // Configuration de la broche trigger en sortie
  pinMode(triggerPin, OUTPUT);
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(2);

  // Envoi d’une impulsion de 10 microsecondes pour déclencher l’émission ultrasonique
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);

  // Configuration de la broche echo en entrée
  pinMode(echoPin, INPUT);

  // Mesure du temps de retour de l’onde sonore (en microsecondes)
  return pulseIn(echoPin, HIGH);
}

void setup()
{
  // Configuration des broches des LEDs en sortie
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
}

void loop()
{
  // Calcul de la distance en centimètres
  // 0.01723 correspond à la conversion du temps (µs) en distance (cm)
  float distance = 0.01723 * readUltrasonicDistance(A0, A1);

  // Cas 1 : objet éloigné
  if (distance > 100) {
    digitalWrite(11, HIGH); // LED 1 allumée
    digitalWrite(12, LOW);
    digitalWrite(13, LOW);
  }

  // Cas 2 : distance intermédiaire
  if (distance > 50 && distance <= 100) {
    digitalWrite(12, HIGH); // LED 2 allumée
    digitalWrite(11, LOW);
    digitalWrite(13, LOW);
  }

  // Cas 3 : objet proche
  if (distance > 20 && distance <= 50) {
    digitalWrite(13, HIGH); // LED 3 allumée
    digitalWrite(11, LOW);
    digitalWrite(12, LOW);
  }

  // Petite pause pour améliorer la stabilité de la simulation
  delay(10);
}
```

Résultats :

[![IMG_0271.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-0271.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-0271.jpeg)

[![IMG_0279.jpeg](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/scaled-1680-/img-0279.jpeg)](https://wiki.fablab.sorbonne-universite.fr/BookStack/uploads/images/gallery/2026-02/img-0279.jpeg)

##### **Analyse**

Le capteur ultrasonique HC-SR04 mesure la distance en envoyant une onde sonore et en calculant le temps nécessaire à son retour après réflexion sur un obstacle. Cette durée est convertie en distance grâce à la vitesse du son, en tenant compte du trajet aller-retour.

Le programme utilise des conditions (`if`) pour allumer une LED différente selon la distance mesurée. La simulation sur TinkerCAD a permis de vérifier le bon fonctionnement du câblage et de la logique avant la réalisation réelle.

##### **Résultats obtenus**

Le système a fonctionné correctement : les LEDs s’allument selon les seuils de distance définis dans le programme. Plus l’objet se rapproche, plus la LED correspondante change, ce qui permet une signalisation visuelle claire et cohérente de la distance mesurée.