Table des matières

Installation version portable à l'IUT

https://openscad.org/downloads.html

version 64bits zip: https://files.openscad.org/OpenSCAD-2021.01-x86-64.zip

Miroir: https://bvdp.inetdoc.net/files/openscad/OpenSCAD-2021.01-x86-64.zip

Thingiverse

Exemples de modèles 3D personnalisables: https://www.thingiverse.com/search?q=customizable&page=1&type=things&sort=relevant

Exemple de grille de ventilateur : https://www.thingiverse.com/apps/customizer/run?thing_id=2802474

fichier openscad: https://bvdp.inetdoc.net/files/iut/td_openscad/customizable_fan_cover.scad

Exemple d'arbre: https://www.thingiverse.com/apps/customizer/run?thing_id=279864

Exemples de librairies 3D: https://www.thingiverse.com/search?q=library&page=1&type=things&sort=relevant

Notations pour les changements de repères

Choix des notations de: https://www.gdr-robotique.org/cours_de_robotique/online/Khalil-Dombre_Modelisation/Khalil-Dombre_Modelisation.pdf

Matrice de rotation dont les colonnes sont les axes du repère $i$ exprimés dans le repère $j$: $^i_{}R_{j}$

Vecteur translation exprimant l'origine du repère $j$ dans le repère $i$: $^i_{}T_{j}$

Matrice de changement de repère:

$^i_{}M_{j}=\begin{bmatrix} ^i_{}R_{j} & ^i_{}T_{j}\\ 0 & 1 \end{bmatrix} $

Matrice rotation dans le plan

https://fr.wikipedia.org/wiki/Matrice_de_rotation

Solution TD1

librepere.scad
////////////////////////////////
module fleche(resolution=60){
    cylinder(h = 0.5, r1 = 0.1, r2 = 0.1, center = false,$fn=resolution);
    translate([0,0,0.5])
        cylinder(h = 0.5, r1 = 0.2, r2 = 0, center = false,$fn=resolution);
}
////////////////////////////////
module repere(){
    color("red")
        rotate(90,[0,1,0])  //équivalent à rotate([0,90,0])
            fleche(10);
    color("green")
        rotate(-90,[1,0,0])
            fleche(10);
    color("blue")
        rotate(0,[0,1,0])
            fleche(10);
}
////////////////////////////////
TD1.scad
use <librepere.scad>
repere();
 
/*
translate([1,2,3]) repere();
//équivalent à:
angle=0;
multmatrix(m = [ [cos(angle), -sin(angle), 0, 1],
                 [sin(angle),  cos(angle), 0, 2],
                 [         0,           0, 1, 3],
                 [         0,           0, 0,  1]
              ]) repere();
*/
/*
rotate([0,0,45]) repere();
//équivalent à: 
angle=45;
multmatrix(m = [ [cos(angle), -sin(angle), 0, 0],
                 [sin(angle),  cos(angle), 0, 0],
                 [         0,           0, 1, 0],
                 [         0,           0, 0,  1]
              ]) repere();
*/
 
scale([0.5,1,2]) repere();
//équivalent à: 
multmatrix(m = [ [0.5, 0, 0, 0],
                 [0, 1, 0, 0],
                 [0, 0, 2, 0],
                 [0, 0, 0,  1]
              ]) repere();
 
 

Exemple de modélisation Denavit-Hartenberg avancé

Matrice de Denavit Hartenberg, notation de Khalil et Kleinfinger page 3 de: https://www.gdr-robotique.org/cours_de_robotique/online/Khalil-Dombre_Modelisation/Khalil-Dombre_Modelisation.pdf

dh.scad
//B. Vandeportaele 2023
 
//les angles sont en degrés!
use <librepere.scad>
//////////////////////////////////
//matrice de Denavit Hartenberg, notation de Khalil et Kleinfinger page 3 de:
//https://www.gdr-robotique.org/cours_de_robotique/online/Khalil-Dombre_Modelisation/Khalil-Dombre_Modelisation.pdf
module matDh(alpha=0,d=0,theta=0,r=0){
    multmatrix(m = [ [cos(theta)           , -sin(theta), 0, d],
                     [cos(alpha)*sin(theta), cos(alpha)*cos(theta), -sin(alpha), -r*sin(alpha)],
                     [sin(alpha)*sin(theta), sin(alpha)*cos(theta),  cos(alpha),  r*cos(alpha)],
                     [         0           ,           0          ,      0     ,    1      ]   ])
        children(); 
    } 
//////////////////////////////////
module robot(tabtheta){
repere();
//exemples d'utilisation de matDh
//matDh(alpha=10,d=0,theta=0,r=0) repere();
//matDh(alpha=0,d=1,theta=0,r=0) repere();
//matDh(alpha=0,d=0,theta=10,r=0) repere();    
//matDh(alpha=0,d=0,theta=0,r=1) repere();        
//matDh(alpha=10,d=1,theta=10,r=1) repere();            
//pour animer:    
//matDh(alpha=10,d=1,theta=180*sin($t*360),r=1) repere();                
 
///////////////////////////////////
 
d3=5;
rl4=6;
 
 
matDh(theta=tabtheta[1-1]){
    repere();                    
    matDh(alpha=90,theta=tabtheta[2-1]){
        repere();   
        matDh(d=d3,theta=tabtheta[3-1]){
            repere();   
            matDh(alpha=-90,theta=tabtheta[4-1],r=rl4){
                repere();   
                matDh(alpha=90,theta=tabtheta[5-1]){
                  repere();   
                  matDh(alpha=-90,theta=tabtheta[6-1]){
                    repere();           
                    }       
                }        
            }        
        }               
    }        
}
}
////////////////////////////////////////////////////////////////
//animer avec angle= $t*360
tabtheta=[$t*360,-10,0,0,0,0];
robot(tabtheta);

A faire pour la seconde séance

Modéliser la molécule d'eau: https://en.wikipedia.org/wiki/Properties_of_water

TD2

Modélisation d'une palette:

Version faite en TD

td2.scad
//B. Vandeportaele 2023
use <librepere.scad>
eps=0.0001;
 
resolution=20;  //paramètre pour régler le niveau de détail du modèle rendu
bords_arrondis=1; //1 pour sphere, 2 pour cylindre
 
/////////////////////
module piece(jeu=0){
rotate([90,0,0])
    translate([0,0,-10])
        cylinder(h=20,r=15+jeu,$fn=resolution);
}
/////////////////////
module palette(){
rotate([90,0,0])    
    union(){
        difference(){
            minkowski(){
                #linear_extrude(height = 400, center = true, convexity = 10, twist =0)
                    polygon([[0,0],[100,0],[100,50],[0,100]], [[0,1,2,3]], convexity = 10);
                if (bords_arrondis==1){
                    sphere(r=4,$fn=resolution);
                } else {
                    //rotate([90,0,0])
                    cylinder(r=4,h=1,$fn=resolution);
                }
            }
        translate([0,104,0]) 
            rotate([0,0,atan2(-50,100)])
                for (b =[1:2]){    
                    for (a =[-4:4]){
                       echo(a+b*9);        // affichage numéro pièce
                       if (((a+b*9) % 4 )!=0){
                            translate([b*42-5,0,a*42])
                            //scale([20,20,20]) repere();
                            piece(0.5);
                        }                
                    }
                 }
        translate([0,104,0]) 
            rotate([0,0,atan2(-50,100)])
                hull(){
                    for (b =[1,2]){    
                        for (a =[-4,4]){
                            echo(a+b*9);     // affichage numéro pièce
                            if (((a+b*9) % 4 )!=0){
                                translate([b*42-5,9,a*42])
                                    //scale([20,20,20]) repere();
                                    piece(0.5);
                            }
                        }
                    }
                }
        }
        translate([15,10,205-eps])
            scale([1.2,2.1,1])
                linear_extrude(height = 10, center = true, convexity = 10, twist =0)
                    text("IUT GEII");
    }
}
//////////////////:
palette();

Version étendue

td2.scad
include <repere.scad>
////////////////////
//Paramètres réglables:
resolution=20; //résolution réglable pour générer le maillage
nbtrouj=7;  //paramètre pour faire varier le nombre de trous sur l'axe j, valeur doit être impaire!
rayoncourbure=10; //rayon de courbure pour arrondir les arêtes,la palette n'est pas agrandie quand on change le rayon
////////////////////
module piece(jeu=0){
    rotate([90,0,0])
        translate([0,0,-10])
            cylinder(h=20,r=15+jeu,$fn=resolution);   
}
////////////////////
module palette(){
    rotate([+90,0,0])
        difference(){
            union(){
               #minkowski(){
                    linear_extrude(height = nbtrouj*42+22-2*rayoncourbure, center = true, convexity = 10)
                       //polygon(points=[[0,0],[100,0],[100,50],[0,100]],paths=[[0,1,2,3]]);                        
                        polygon(points=[[rayoncourbure,rayoncourbure],[100-rayoncourbure,rayoncourbure],[100-rayoncourbure,50-rayoncourbure*0.6],[rayoncourbure,100-rayoncourbure*1.6]],paths=[[0,1,2,3]]);
                    sphere(r=rayoncourbure,$fn=resolution); // ou rotate([90,0,0])  cylinder(r=4,$fn=resolution);
                }
               translate([20,20,((nbtrouj*42+22)/2)])
                    scale([1.2,2.1,1])
                        linear_extrude(height = 5, center = true, convexity = 10)
                            text("IUT GEII");
            }
        //hull()
            {
            translate([0,100,0])
                //rotate([0,0,-atan(50/100)]) 
                rotate([0,0,atan2(-50,100)])
                //rotate([0,0,atan2(-50,100-14)])
                //for (i=[-4:4]){
                for (i=[-floor(nbtrouj/2):floor(nbtrouj/2)]){    
                    for (j=[1:2]){
                        if(((j*9+i)%4)!=0){
                            translate([j*42-5,0,i*42]){
                                repere();
                                #piece();
                            }            
                        }
                        else
                            echo("pas ici");        
                    }
                }
            }
        }
}
////////////////////
palette();