Valentin KOK
Impression d'un objet simple (16/12/2025)
Pour la première séance, l'objectif était d'imprimer un objet simple de son choix pour se familiariser avec les imprimantes.
J'ai choisi un modèle 3D d'un modèle réduit d'une épée en téléchargeant un fichier disponible sur le site printables.com
L'objet est imprimé en 2 parties qui doivent ensuite être assemblées avec de la colle. J'ai réduit la taille à une longueur d'environ 5cm pour une largeur de 2cm, pour réduire le temps d'impression, et j'ai choisi un réglage de 20mm. Ces réglages donnent un temps d'impression de 5 minutes
Le résultat s'est imprimé sans difficulté particulière, il suffit ensuite de coller les deux parties
Découverte de OpenSCAD
L'objectif était d'utiliser le logiciel OpenSCAD pour modéliser un objet en se familiarisant avec les fonctions du logiciel.
J'ai modélisé un visage sur un objet de type pièce de monnaie en décomposant le modèle en différents "modules":
- Le module "face" constitue la base de l'objet, c'est un disque en forme de pièce de monnaie réalisé en utilisant la fonction linear_extrude sur deux cercles et en faisant leur différence.
- Le module "eye" constitue un oeil. Pour faire le contour de l'oeil, j'ai tracé une courbe polynomiale en définissant une fonction en x^2. La courbe est tracée avec des cylindres. En traçant l'opposé de cette courbe on obtient deux tracés qui permettent de dessiner le contour de l'oeil.
- Le module "mouth" permet de tracer une bouche en utilisant aussi une courbe polynomiale. Je l'ai tracé avec des cylindres plus gros que pour les yeux.
Ensuite en utilisant la fonction union() j'ai réuni ces modules, en copiant deux fois le module eye et en traçant des sourcils (en utilisant des cubes + linear_extrude).
Le code :
function f(x) = 0.1*x^2 ;
function g(x) = 0.02*x^2 ;
module face(){
union() {
translate([0,25]) {
linear_extrude(2){
circle(30);
}
}
difference() {
translate([0,25,2]) {
linear_extrude(2){
circle(30);
}
}
translate([0,25,0]) {
linear_extrude(10){
circle(28);
}
}
}
}
}
module eye() {
for (x = [ -15 : 5 : 15 ])
translate([x, f(x), 0]) cylinder(5,3,2);
translate([0,50]) {
for (x = [ -15 : 5 : 15 ])
translate([x, -f(x), 0]) cylinder(5,3,2);
}
difference(){
translate([0,25]) {
cylinder(5,5,5);
}
translate([0,25,0]) {
cylinder(10,2,2);
}
}
}
module mouth() {
for (x = [ -15 : 5 : 15 ])
translate([x, g(x), 0]) cylinder(3,4,4);
}
scale([2,2,2]) {
union() {
scale([1.5,1.5,1.5]) face();
translate([10,5,3]) {
scale([0.5,0.5,0.5]) {
eye();
}
}
translate([10,45,3]) {
scale([0.5,0.5,0.5]) {
eye();
}
}
translate([25,45,3]) {
rotate([0,0,85]){
cube([20,2,3]);
}
}
translate([25,10,3]) {
rotate([0,0,95]){
cube([20,2,3]);
}
}
translate([-30,38,3]) {
rotate([0,0,270]){
mouth();
}
}
}
}
Création d'un objet avec pause pendant l'impression : Dé pipé
J'ai choisi de créer un dé truqué : pour cela j'ai réalisé un cube creux et j'ai creusé sur les faces pour marquer les chiffres. Ensuite j'ai réalisé un poids qui sera imprimé en même temps que le dé.
Lorsque le poids est complètement imprimé, je mets l'impression en pause. Ensuite je peux coller le poids à l'intérieur du dé sur la face du bas pour truquer le dé.
Mise en pause de l'impression :
Collage du poids à l'intérieur du dé :
Résultat final :
Conclusion : le poids est collé à l'intérieur de façon à faire ressortir la face 1 plus souvent. Cependant le poids étant de petite taille et imprimé en PLA, il est un peu trop léger pour que l'effet soit significatif. Pour faire un dé avec un truquage vraiment efficace il faudrait réaliser un poids de plus grande taille ou prendre une masse faite dans un matériau plus lourd.
Code :
taille_de = 20;
r = 1.5;
module de(taille_de, courbure) {
difference(){
minkowski() {
cube(taille_de - 2*courbure, center=true);
sphere(courbure);
}
cube(taille_de-2,center=true);
}
}
module point(x, y, z, axe) {
rotate(axe)
translate([x, y, z])
sphere(r = r);
}
translate([0,0,taille_de/2])difference() {
de(taille_de,2);
// Face 1
point(0, 0, taille_de/2, [0,0,0]);
// Face 6
point(-4, -4, taille_de/2, [180,0,0]);
point( 4, -4, taille_de/2, [180,0,0]);
point(-4, 0, taille_de/2, [180,0,0]);
point( 4, 0, taille_de/2, [180,0,0]);
point(-4, 4, taille_de/2, [180,0,0]);
point( 4, 4, taille_de/2, [180,0,0]);
// Face 2
point(-4, -4, taille_de/2, [0,90,0]);
point( 4, 4, taille_de/2, [0,90,0]);
// Face 5
point(-4, -4, taille_de/2, [0,-90,0]);
point( 4, -4, taille_de/2, [0,-90,0]);
point( 0, 0, taille_de/2, [0,-90,0]);
point(-4, 4, taille_de/2, [0,-90,0]);
point( 4, 4, taille_de/2, [0,-90,0]);
// Face 3
point(-4, -4, taille_de/2, [90,0,0]);
point( 0, 0, taille_de/2, [90,0,0]);
point( 4, 4, taille_de/2, [90,0,0]);
// Face 4
point(-4, -4, taille_de/2, [-90,0,0]);
point( 4, -4, taille_de/2, [-90,0,0]);
point(-4, 4, taille_de/2, [-90,0,0]);
point( 4, 4, taille_de/2, [-90,0,0]);
}
module poids(){
cube([taille_de/3,taille_de/2,taille_de/6], center=true);
}
translate([40,0,taille_de/12]) poids();
Partie Arduino : Découverte Arduino : Valentin KOK et Mohammed-Amine MOUBARRAD
Découverte Arduino : Valentin KOK et Mohammed-Amine MOUBARRAD
Cette partie vise à se familiariser avec les microcontrôleurs Arduino en réalisant des circuits avec programmation.
1. Circuit avec deux LED décorrelées
L'objectif de l'exercice est de partir d'un circuit Arduino simple avec une LED, et de rajouter une LED pour faire clignoter les deux de manière non corrélée. Pour cela on a relié une LED au port 12 et l'autre au port 13, ce qui permet d'écrire un programme pour contrôler chaque LED.
unsigned long Temps_precedentR = 0;
unsigned long Temps_precedentJ = 0;
unsigned long Temps_actuel;
int intervalleR = 1000;
int intervalleJ = 3000;
int etat_ledR = LOW;
int etat_ledJ = LOW;
void setup() {
pinMode(12,OUTPUT);
pinMode(13,OUTPUT);
}
void loop() {
Temps_actuel = millis();
if (Temps_actuel-Temps_precedentR >= intervalleR){
Temps_precedentR = Temps_actuel;
if (etat_ledR == LOW){
etat_ledR = HIGH;
}else{
etat_ledR= LOW;}
digitalWrite(12, etat_ledR);
}
if (Temps_actuel-Temps_precedentJ >= intervalleJ){
Temps_precedentJ = Temps_actuel;
if (etat_ledJ == LOW){
etat_ledJ = HIGH;
}else{
etat_ledJ= LOW;}
digitalWrite(13, etat_ledJ);
}
}Dans ce programme on définit des durées de clignotement (intervalles) différents pour la LED rouge et pour la LED jaune. Cela permet de faire clignoter la LED rouge pendant 1 seconde et la LED jaune pendant 3 secondes.
2. Circuit avec un capteur qui réagit à un élément extérieur
Pour ce deuxième circuit le but est de réaliser un circuit qui puisse réagir à un facteur extérieur. Pour cela nous avons choisi d'utiliser un capteur de distance, car cela correspond à une des technologies que nous souhaitons intégrer pour notre PPE.
Le circuit comporte une LED jaune. Si le capteur détecte un objet dans sa distance de détection, la LED s'allume.
void setup() {
Serial.begin(9600);
pinMode(12,INPUT);
}
void loop() {
delay(1000);
if(digitalRead(12)==LOW) {
Serial.println("Magnet in range");
digitalWrite(13,HIGH);
}
else {
Serial.println("Magnet out of range");
digitalWrite(13,LOW);
}
}
Pas d'objet détecté : LED éteinte
Objet détecté : LED allumée
Limites : on peut constater que lorsque la LED est allumée, sa lumière est faible. Cela est peut-être dû à un courant trop faible dans notre circuit, ce que nous n'avons pas réussi à régler sans amplificateur de courant.