VARGAS Lilian

Activité 1. Découverte de l’impression 3D avec PrusaSlicer

Informations

Lilian VARGAS RAMIREZ
Lilian.vargas_ramirez@etu.sorbonne-universite.fr
UM4MN011-Processus d'innovation - S2-25
5/01/2026 (finalisé le même jour)

Contexte

Cette première activité s’inscrit dans une phase de prise en main des outils d'impression 3D. L’objectif principal était de découvrir le fonctionnement d’une imprimante 3D Prusa ainsi que le logiciel de tranchage PrusaSlicer. L’activité permet d’appréhender le flux complet d’impression 3D, de la sélection d’un modèle existant jusqu’à la préparation du fichier d’impression.

Objectifs

Découvrir l’écosystème Prusa (imprimante et logiciel).
Comprendre le rôle du slicer dans le processus d’impression 3D.
Apprendre à générer un fichier G-code exploitable par une imprimante 3D.
Se familiariser avec l’utilisation d’une clé USB pour lancer une impression.

Matériel

Ordinateur
Clé USB
Filament PLA

Machines utilisées

Imprimante 3D Prusa MK4S

Construction

Étape 1

Recherche d’un modèle 3D existant sur la plateforme Printables intégrée à PrusaSlicer.

Étape 2

Importation du modèle dans PrusaSlicer, sélection des paramètres d’impression standards (PLA, hauteur de couche standard). L’activation des supports s’est révélée indispensable afin d’assurer l’adhérence au plateau: sans matériaux de support, le modèle ne disposait pas de surface de départ suffisante, ce qui a conduit à une impression à vide.

Étape 3

Export du fichier G-code sur une clé USB afin de pouvoir lancer l’impression sur l’imprimante 3D.

Journal de bord

05/01/2026

Première prise en main de l’imprimante et du logiciel. Cette activité a permis de comprendre le rôle central du slicer et d’observer les paramètres influençant le temps et la qualité d’impression. Aucun problème majeur rencontré.

Activité 2. Initiation à la conception 3D avec OpenSCAD et impression

Contexte

Cette activité vise à introduire la conception 3D à l’aide du logiciel OpenSCAD. Contrairement à la première activité, il s’agit ici de produire un objet à partir de code, afin de comprendre les bases de la modélisation, puis de l’intégrer dans un flux d’impression 3D complet via PrusaSlicer.

Objectifs

Découvrir la modélisation 3D par le code avec OpenSCAD.
Comprendre la logique de construction d’objets simples à partir de primitives.
Exporter un modèle 3D au format STL.
Utiliser deux logiciels clés du processus d’impression 3D : OpenSCAD et PrusaSlicer.
Finaliser le processus par la génération d’un G-code imprimable.

Matériel

Ordinateur
Clé USB
Filament PLA

Machines utilisées

Imprimante 3D Prusa MK4S

Construction

Étape 1

Écriture d’un script OpenSCAD simple utilisant des formes géométriques de base afin de démontrer la manipulation du logiciel et la logique de conception.

Étape 2

Rendu du modèle dans OpenSCAD (render CGAL) puis export du fichier au format STL (binaire).

Étape 3

Import du fichier STL dans PrusaSlicer, paramétrage de l’impression, génération du G-code et export sur clé USB en vue de l’impression.

Journal de bord

05/01/2026

Première approche de la modélisation par le code. L’utilisation d’OpenSCAD a permis de mieux comprendre la construction logique des objets 3D et le lien direct entre conception numérique et fabrication. L’enchaînement OpenSCAD → PrusaSlicer → impression a rendu le processus globalplus clair et cohérent.

Activité 3. Modélisation d’une coulissante (rail + slider) sous OpenSCAD

Contexte

Cette activité s’inscrit dans la continuité de la prise en main de la modélisation 3D paramétrique et de l’impression 3D.
L’objectif était de concevoir un objet mécanique nécessitant des dimensions précises, afin de valider la compréhension des contraintes liées à l’assemblage et au mouvement entre deux pièces imprimées.

Choix de l’objet :

Objet mécanique à dimensions importantes (engrenage, coulissante, accroche)
Objet entremêlé/emboîté ou contenant une pièce métallique à l’intérieur (roulement à bille, etc.)

Option choisie :

1. Coulissante: conception d’un rail + slider permettant un mouvement linéaire.

Objectifs

Concevoir un mécanisme simple de translation (coulissante) en modélisation paramétrique (OpenSCAD).
Gérer des tolérances d’assemblage adaptées à l’impression FDM (PLA).
Exporter les pièces, les trancher dans PrusaSlicer et réaliser une impression fonctionnelle.
Valider le bon fonctionnement en conditions réelles (glissement fluide, absence de blocage).

Matériel

Ordinateur
Clé USB
Filament PLA
Pince/cutter pour retrait du support

Machines utilisées

Imprimante 3D Prusa MK4S (PLA)

Construction

Étape 1

Modélisation paramétrique dans OpenSCAD. Le modèle est composé de deux pièces imprimables:

Rail: profil en “T” inversé (base + cou + tête)
Slider: bloc contenant un canal interne correspondant au négatif du rail (avec tolérance).

Les dimensions clés sont pilotées par paramètres afin de faciliter les ajustements.

Point important:
Le défi principal a été d’assurer un emboîtement correct entre le rail et le slider :

tol (tolérance) pour éviter un serrage excessif dû aux imprécisions d’impression
clear (jeu vertical) pour limiter le frottement

Une flèche décorative a été ajoutée au-dessus du slider pour améliorer l’esthétique tout en conservant une pièce monobloc.

// ================================
// COULISSANTE SIMPLE (RAIL + SLIDER)
// ================================

part = "assembly"; // "rail", "slider", "assembly"

// --- Paramètres principaux ---
L = 120;        // longueur du rail
W = 28;         // largeur totale du rail
H = 16;         // hauteur totale du rail

track_h = 10;   // hauteur de la zone de guidage
neck_w  = 10;   // largeur du "cou" (partie étroite du rail)
head_w  = 20;   // largeur de la "tête" (forme en T inversé)

tol = 0.35;     // tolérance (0.25–0.45 pour PLA)
clear = 0.6;    // jeu vertical pour permettre le glissement sans frottement

// Slider (carro)
slider_L = 45;
slider_H = 18;  // hauteur du slider (incluant la partie supérieure)
slider_overhang = 3; // dépassement extérieur esthétique

$fn = 80;

// ================================
// RAIL: T inversé (guide mâle)
// ================================
module rail(){
  union(){
    // base
    cube([L, W, track_h], center=false);

    // cou (partie plus étroite)
    translate([0, (W-neck_w)/2, track_h])
      cube([L, neck_w, H-track_h], center=false);

    // tête (plus large en partie supérieure) : forme en "T"
    translate([0, (W-head_w)/2, H-4])
      cube([L, head_w, 4], center=false);
  }
}

// -----------------------------
// Helper: rail plein (même géométrie que le rail)
// avec "expand" pour la tolérance
// NE PAS exporter: utilisé uniquement comme négatif dans le slider
// -----------------------------
module rail_solid(len, expand=0){
  union(){
    // base
    translate([0, -expand, -expand])
      cube([len, W + 2*expand, track_h + expand], center=false);

    // cou
    translate([0, (W-neck_w)/2 - expand, track_h - expand])
      cube([len, neck_w + 2*expand, (H-track_h) + 2*expand], center=false);

    // tête (T)
    translate([0, (W-head_w)/2 - expand, (H-4) - expand])
      cube([len, head_w + 2*expand, 4 + 2*expand], center=false);
  }
}

// ================================
// FLÈCHE ESTHÉTIQUE
// ================================
module arrow(length=20, width=12, height=4){
  union(){
    // corps rectangulaire
    cube([length, width, height], center=false);

    // pointe triangulaire
    translate([length, 0, 0])
      linear_extrude(height=height)
        polygon(points=[
          [0, 0],
          [0, width],
          [width/2, width/2]
        ]);
  }
}

// ================================
// SLIDER FIXÉ: chariot correctement ajusté
// (canal interne = négatif du rail + tolérance)
// ================================
module slider(){
  top_th  = 3;
  side_th = 3;
  entry   = 1.2;

  union(){

    // ===== CORPS DU SLIDER =====
    difference(){
      cube([slider_L, W + 2*(slider_overhang + side_th), H + top_th], center=false);

      translate([0, slider_overhang + side_th, -clear])
        rail_solid(slider_L, expand=tol);

      translate([-1, slider_overhang + side_th - 1, -50])
        cube([slider_L + 2, W + 2 + 2*tol, 50], center=false);

      translate([0, slider_overhang + side_th - entry, H-4-entry])
        cube([2, W + 2*entry, 4 + 2*entry], center=false);
    }

    // ===== FLÈCHE ESTHÉTIQUE SUPÉRIEURE =====
    translate([slider_L/2 - 10,   // centrée en X
               (W + 2*(slider_overhang + side_th))/2 - 6,  // centrée en Y
               H + top_th])       // positionnée au-dessus du slider
      arrow(length=20, width=12, height=4);
  }
}

// ================================
// ASSEMBLAGE (visualisation uniquement)
// ================================
module assembly(){
  color("gold") rail();

  // largeur réelle du slider sur l’axe Y :
  // W + 2*(slider_overhang + side_th)
  side_th = 3;  // <-- doit être identique à la valeur utilisée dans slider()

  slider_W = W + 2*(slider_overhang + side_th);

  // Pour centrer le slider par rapport au rail :
  // Y = -((slider_W - W) / 2)
  y_align = - (slider_W - W)/2;

  translate([20, y_align, 0])
    color("lightgreen") slider();
}

// ================================
// Sélecteur
// ================================
if (part=="rail") rail();
if (part=="slider") slider();
if (part=="assembly") assembly();

Étape 2

Export séparé des fichiers STL :

part = "rail" → export du rail
part = "slider" → export du slider
part = "assembly" sert uniquement à visualiser l’assemblage dans OpenSCAD, pas exporté.

Étape 3

Tranchage dans PrusaSlicer et génération du G-code. Importation des STL dans PrusaSlicer. Paramètres d’impression standards PLA (hauteur de couche standard).

Point critique: supports d’impression
L’activation de la génération de supports (“générer le matériau de support”) a été indispensable. Sans supports, certaines zones n’étaient pas correctement soutenues et l’impression ne pouvait pas se construire correctement (déplacement de la tête sans dépôt efficace / adhérence insuffisante selon les zones). Après activation des supports, le G-code a pu être généré et l’impression lancée dans de bonnes conditions.

Étape 4

Impression des deux pièces en PLA. Retrait des supports

Point critique: retrait complet des supports
Le mécanisme étant basé sur des dimensions précises, le moindre résidu de support dans le canal du slider empêchait un glissement fluide. Un nettoyage soigneux a été nécessaire pour obtenir une coulissante fonctionnelle.

Journal de bord

16/01/2026

Définition des paramètres principaux (dimensions du rail, géométrie en T).
Première version du slider et premiers tests de visualisation en assemblage.

27/01/2026

Ajustements de tolérances pour garantir l’emboîtement et le mouvement.
Correction de l’alignement en assemblage et ajout d’un élément décoratif.

28/01/2026

Tranchage sur PrusaSlicer et impression en PLA.
Post-traitement: retrait complet des supports indispensable pour permettre le bon coulissement.
Test final: le slider se déplace correctement sur le rail après nettoyage.

Activité 4. Clignotement de deux LEDs à fréquences différentes avec ARDUINO

Contexte

Cette activité avait pour objectif d’introduire la programmation Arduino appliquée à un montage électronique simple. Dans le cadre de ma formation en électronique, j’applique systématiquement une phase de simulation préalable à l’aide de TinkerCAD, avant toute manipulation physique. Cette pratique permet :

de valider le fonctionnement logique du circuit

d’éviter les erreurs de câblage

de prévenir la détérioration des composants électroniques qui sont souvent partagés entre plusieurs étudiants.

Objectifs

Réaliser un montage Arduino permettant de faire clignoter deux LEDs indépendamment.

Implémenter deux fréquences distinctes:
- LED 1: toutes les 2 secondes
- LED 2 : toutes les 3 secondes

Utiliser la fonction millis() afin d’éviter l’utilisation de delay() et permettre une exécution simultanée non bloquante.

Vérifier le comportement du circuit par simulation avant la mise en œuvre réelle.

Matériel

Carte Arduino Uno

2 LEDs

2 résistances 220 Ω

Breadboard

Fils de connexion

Logiciel Arduino IDE

Simulateur TinkerCAD

Machines et outils utilisées

Arduino Uno

Breadboard

TinkerCAD (simulation)

Arduino IDE (programmation)

Construction

Étape 1

Description du circuit.

Le montage est composé de deux LEDs connectées chacune à une sortie numérique distincte de l’Arduino:

LED 1 connectée à la broche 8

LED 2 connectée à la broche 9

Chaque LED est associée à une résistance de 220 Ω montée en série afin de limiter le courant et protéger le composant.
Les cathodes des LEDs sont reliées à la masse (GND). Le choix des résistances est cohérent avec les caractéristiques standards des LEDs et la tension de sortie de l’Arduino (5 V).

Étape 2

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

Chaque LED change d’état (ON/OFF) lorsque l’intervalle correspondant est écoulé, sans interrompre l’exécution du programme principal.

// Définition des broches utilisées pour les LEDs
const int led1 = 8;   // LED 1 connectée à la broche numérique 8
const int led2 = 9;   // LED 2 connectée à la broche numérique 9

// Variables pour mémoriser le dernier instant de basculement
unsigned long previousMillis1 = 0; // Temps précédent pour la LED 1
unsigned long previousMillis2 = 0; // Temps précédent pour la LED 2

// Intervalles de clignotement (en millisecondes)
const long interval1 = 2000; // 2 secondes pour la LED 1
const long interval2 = 3000; // 3 secondes pour la LED 2

// États actuels des LEDs
bool led1State = LOW; // LED 1 éteinte au démarrage
bool led2State = LOW; // LED 2 éteinte au démarrage

void setup() {
  // Configuration des broches comme sorties
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
}

void loop() {
  // Récupération du temps actuel depuis le démarrage du programme
  unsigned long currentMillis = millis();

  // Gestion de la LED 1 (clignotement toutes les 2 secondes)
  if (currentMillis - previousMillis1 >= interval1) {
    previousMillis1 = currentMillis;   // Mise à jour du temps de référence
    led1State = !led1State;             // Inversion de l’état de la LED
    digitalWrite(led1, led1State);      // Application de l’état sur la broche
  }

  // Gestion de la LED 2 (clignotement toutes les 3 secondes)
  if (currentMillis - previousMillis2 >= interval2) {
    previousMillis2 = currentMillis;   // Mise à jour du temps de référence
    led2State = !led2State;             // Inversion de l’état de la LED
    digitalWrite(led2, led2State);      // Application de l’état sur la broche
  }
}

Journal de bord

30/01/2026

Simulation du circuit sur TinkerCAD afin de valider le câblage et le comportement des LEDs.

Implémentation du code Arduino avec temporisation non bloquante.

Vérification du clignotement indépendant des deux LEDs à des fréquences différentes.

03/02/2026

Reproduction du montage sur breadboard après validation en simulation.

Activité 5. Capteur ultrasonique et signalisation par LEDs avec ARDUINO

Contexte

Cette activité avait pour objectif de mettre en œuvre un capteur afin de piloter des actionneurs (LEDs) en fonction des données mesurées. Conformément aux bonnes pratiques acquises lors de ma formation en électronique, le circuit a d’abord été simulé sur TinkerCAD avant toute réalisation physique.
Cette étape permet :

de valider le câblage du capteur et des LEDs

de tester la logique du programme

d’éviter tout risque de détérioration des composants, souvent partagés entre plusieurs étudiants.

Objectifs

Utiliser un capteur de distance ultrasonique pour mesurer la proximité d’un objet.

Interpréter la distance mesurée afin de déclencher différentes sorties.

Commander trois LEDs en fonction de seuils de distance définis.

Comprendre la conversion du temps de propagation de l’onde sonore en distance.

Mettre en œuvre une logique conditionnelle simple (if).

Matériel

Carte Arduino Uno

Capteur ultrasonique HC-SR04

3 LEDs

3 résistances 220 Ω

Breadboard

Fils de connexion

Logiciel Arduino IDE

Simulateur TinkerCAD

Machines et outils utilisées

Arduino Uno

Breadboard

TinkerCAD (simulation)

Arduino IDE (programmation)

Construction

Étape 1

Description du circuit. Le capteur ultrasonique HC-SR04 est connecté à l’Arduino de la manière suivante:

Trigger → broche analogique A0

Echo → broche analogique A1

VCC → 5 V

GND → masse (GND)

Trois LEDs sont connectées aux sorties numériques:

LED 1 → broche 11

LED 2 → broche 12

LED 3 → broche 13

Chaque LED est protégée par une résistance de 220 Ω montée en série afin de limiter le courant.

Étape 2

Principe de fonctionnement. Le capteur ultrasonique mesure la distance en envoyant une onde sonore puis en mesurant le temps nécessaire à son retour après réflexion sur un obstacle.

Le programme :

Génère une impulsion sur la broche trigger.

Mesure la durée du signal reçu sur la broche echo.

Convertit cette durée en distance (cm).

Active une LED différente selon la distance mesurée :
- Distance > 100 cm → LED 1
- 50 cm < Distance ≤ 100 cm → LED 2
- 20 cm < Distance ≤ 50 cm → LED 3

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

Journal de bord

02/02/2026

Simulation du circuit sur TinkerCAD afin de valider le câblage et le comportement des LEDs.

Implémentation du code Arduino

Programmation des seuils de distance.

03/02/2026

Vérification du fonctionnement du capteur ultrasonique.

Validation de l’allumage correct des LEDs selon la proximité de l’objet.

Ajustement des conditions logiques pour éviter l’allumage simultané de plusieurs LEDs.

04/02/2026

Reproduction du montage sur breadboard après validation en simulation.