Tristan KREGEL

Prototype d'un objet - no. 1

Description
Il s'agit d'un porte-stylo de forme ronde.

Code dans openSCAD

// Parameter
outer_radius = 10; // Äußerer Radius
inner_radius = 8; // Innerer Radius
height = 50; // Höhe des Stiftehalters
thickness = 2; // Bodenstärke

// Äußerer Zylinder
difference() {
cylinder(h = height, r = outer_radius, $fn = 100); // Äußerer Zylinder
translate([0, 0, thickness]) // Inneren Zylinder verschieben
cylinder(h = height, r = inner_radius, $fn = 100); // Innerer Zylinder
}

Objet dans openSCAD

Objet imprimé

Reglages:

• Imprimante Pruse MSK 45

Prototype d'un objet - no. 2

Description
Il s'agit d'une boîte à bijoux compartiment

// Paramètres
taille_cube = 18;        // Taille du cube extérieur
rayon_sphere = 9;       // Rayon de la sphère intérieure
espace = 2;              // Distance entre la sphère et le cube
rayon_trou = 6;          // Rayon des trous sur les faces du cube

// Module pour le cube extérieur avec des trous
module cube_avec_trous(taille_cube, espace, rayon_trou) {
    difference() {
        // Cube extérieur
        cube([taille_cube, taille_cube, taille_cube], center = true);

        // Creux intérieur (espace pour la sphère)
        cube([taille_cube - 2 * espace, taille_cube - 2 * espace, taille_cube - 2 * espace], center = true);

        // Trous : Crée des trous sur les six faces du cube
        for (i = [-1, 1]) {
            // Trous sur les faces X
            translate([i * taille_cube / 2, 0, 0])
                rotate([0, 90, 0])
                cylinder(h = taille_cube, r = rayon_trou, center = true);

            // Trous sur les faces Y
            translate([0, i * taille_cube / 2, 0])
                rotate([90, 0, 0])
                cylinder(h = taille_cube, r = rayon_trou, center = true);

            // Trous sur les faces Z
            translate([0, 0, i * taille_cube / 2])
                cylinder(h = taille_cube, r = rayon_trou, center = true);
        }
    }
}

// Module pour la sphère intérieure
module sphere_interieure(rayon) {
    translate([0, 0, 0])
        sphere(r = rayon);
}

// Combinaison des modules
union() {
    // Cube extérieur avec trous
    cube_avec_trous(taille_cube, espace, rayon_trou);

    // Sphère intérieure
    sphere_interieure(rayon_sphere);
}

 

Prototype objet no. 3

// Paramètres
base_taille = 40;         // Taille de la base de la pyramide
hauteur_pyramide = 50;    // Hauteur de la pyramide
epaisseur_murs = 3;       // Épaisseur des murs

// Module : Pyramide pleine
module pyramide(taille_base, hauteur) {
    polyhedron(
        points = [
            [0, 0, 0],                         // Point 0 : coin bas gauche
            [taille_base, 0, 0],               // Point 1 : coin bas droit
            [taille_base, taille_base, 0],     // Point 2 : coin haut droit
            [0, taille_base, 0],               // Point 3 : coin haut gauche
            [taille_base/2, taille_base/2, hauteur] // Point 4 : sommet
        ],
        faces = [
            [0, 1, 4], // Face 1
            [1, 2, 4], // Face 2
            [2, 3, 4], // Face 3
            [3, 0, 4], // Face 4
            [0, 1, 2, 3] // Base
        ]
    );
}

// Module : Pyramide creuse
module pyramide_creuse(taille_base, hauteur, epaisseur) {
    difference() {
        // Pyramide extérieure
        pyramide(taille_base, hauteur);

        // Pyramide intérieure (plus petite pour créer le creux)
        translate([epaisseur, epaisseur, 0])
            pyramide(taille_base - 2 * epaisseur, hauteur - epaisseur);
    }
}

// Appel du module
pyramide_creuse(base_taille, hauteur_pyramide, epaisseur_murs);

NEWWWW

// Paramètres
taille_base = 40;        // Longueur de la base de la pyramide
hauteur = 50;            // Hauteur de la pyramide
epaisseur_paroi = 2;     // Épaisseur des parois

// Module pour une pyramide simple
module pyramide(base, height) {
    polyhedron(
        points = [
            [0, 0, height],                // Sommet
            [-base / 2, -base / 2, 0],     // Coin 1
            [base / 2, -base / 2, 0],      // Coin 2
            [base / 2, base / 2, 0],       // Coin 3
            [-base / 2, base / 2, 0]       // Coin 4
        ],
        faces = [
            [0, 1, 2], [0, 2, 3],          // Faces latérales
            [0, 3, 4], [0, 4, 1],          // Faces latérales
            [1, 2, 3, 4]                   // Base
        ]
    );
}

// Module pour une pyramide creuse
module pyramide_creuse(taille_base, hauteur, epaisseur_paroi) {
    difference() {
        // Pyramide extérieure
        pyramide(taille_base, hauteur);

        // Pyramide intérieure (creux)
        translate([0, 0, epaisseur_paroi])
            pyramide(taille_base - 2 * epaisseur_paroi, hauteur - epaisseur_paroi);
    }
}

// Afficher la pyramide creuse
pyramide_creuse(taille_base, hauteur, epaisseur_paroi);