VARGAS Lilian

ActivitéActivité 1. DéDécouverte de l’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éfinalisé le mêmême jour)
  

Contexte

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

Objectifs

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

.      

MatéMatériel

• Ordinateur

• CléClé USB

• Filament PLA
  

Machines utiliséutilisées

Imprimante 3D Prusa MK4S

Construction

ÉÉtape 1

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

ÉÉtape 2

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

ÉÉtape 3

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

Journal de bord

05/01/2026

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

---

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

Contexte

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

Objectifs

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

.      

MatéMatériel

• Ordinateur

• CléClé USB

• Filament PLA
  

Machines utiliséutilisées

Imprimante 3D Prusa MK4S

Construction

ÉÉtape 1

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

ÉÉtape 2

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

ÉÉtape 3

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

Journal de bord

05/01/2026

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

---

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

Contexte

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

Choix de l’l’objet :

1. Objet mémécanique àà dimensions importantes (engrenage, coulissante, accroche)

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

Option choisie :

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

Objectifs

• Concevoir un mémécanisme simple de translation (coulissante) en modémodélisation paraméparamétrique (OpenSCAD).

• GéGérer des tolétolérances d’d’assemblage adaptéadaptées àà l’l’impression FDM (PLA).

• Exporter les pièpièces, les trancher dans PrusaSlicer et réréaliser une impression fonctionnelle.

• Valider le bon fonctionnement en conditions réréelles (glissement fluide, absence de blocage).
  

MatéMatériel

• Ordinateur

• CléClé USB

• Filament PLA
  

• Pince/cutter pour retrait du support

Machines utiliséutilisées

Imprimante 3D Prusa MK4S (PLA)

Construction

ÉÉtape 1

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

• Rail: profil en “T”“T” inverséinversé (base + cou + têtête)

• Slider: bloc contenant un canal interne correspondant au nénégatif du rail (avec tolétolérance).

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

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

• tol (tolétolérance) pour ééviter un serrage excessif dûdû aux impréimprécisions d’d’impression

• clear (jeu vertical) pour limiter le frottement

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

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

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

// --- Paramè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êtête" (forme en T inverséinversé)

tol = 0.35;     // tolétolérance (0.25–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ésupérieure)
slider_overhang = 3; // dédépassement extéextérieur esthéesthétique

$fn = 80;

// ================================
// RAIL: T inverséinversé (guide mâ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êtête (plus large en partie supésupérieure) : forme en "T"
    translate([0, (W-head_w)/2, H-4])
      cube([L, head_w, 4], center=false);
  }
}

// -----------------------------
// Helper: rail plein (mêmême géomégéométrie que le rail)
// avec "expand" pour la tolétolérance
// NE PAS exporter: utiliséutilisé uniquement comme né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ê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ÈFLÈCHE ESTHÉ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ÉFIXÉ: chariot correctement ajustéajusté
// (canal interne = nénégatif du rail + tolé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ÈFLÈCHE ESTHÉESTHÉTIQUE SUPÉSUPÉRIEURE =====
    translate([slider_L/2 - 10,   // centrécentrée en X
               (W + 2*(slider_overhang + side_th))/2 - 6,  // centrécentrée en Y
               H + top_th])       // positionnépositionnée au-dessus du slider
      arrow(length=20, width=12, height=4);
  }
}

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

  // largeur réréelle du slider sur l’l’axe Y :
  // W + 2*(slider_overhang + side_th)
  side_th = 3;  // <-- doit êêtre identique àà la valeur utilisé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éSélecteur
// ================================
if (part=="rail") rail();
if (part=="slider") slider();
if (part=="assembly") assembly();

ÉÉtape 2

Export séparéséparé des fichiers STL :

• part = "rail" →→ export du rail

• part = "slider" →→ export du slider

• part = "assembly" sert uniquement àà visualiser l’l’assemblage dans OpenSCAD, pas exportéexporté.

     

ÉÉtape 3

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

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

ÉÉtape 4

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

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

Journal de bord

16/01/2026

• DéDéfinition des paramèparamètres principaux (dimensions du rail, géomégéométrie en T).

• PremièPremière version du slider et premiers tests de visualisation en assemblage.

27/01/2026

• Ajustements de tolétolérances pour garantir l’emboîl’emboîtement et le mouvement.

• Correction de l’l’alignement en assemblage et ajout d’d’un éléélément dé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édéplace correctement sur le rail aprèaprès nettoyage.

---

Activité

Voir 4.aussi 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 :

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

.   

Résultat

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.