=====Installation version portable à l'IUT=====


https://openscad.org/downloads.html

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

Mirroir: 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

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=====

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

-------------------------------


<file txt 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();

 
</file>





<ifauth @prof>
<file txt td1_2023.scad>

module repere(){
fleche("blue");
rotate([0,90,0])
    fleche();
rotate(-90,[1,0,0])
    fleche("green");
}

repere();
/*
rotate([-45,0,0])
translate([0,0,2])
rotate([45,0,0])
    repere();
*/

/*
translate([0,sqrt(2),sqrt(2)])
    repere();
*/
angle=0;
//rotation=360*$t; //pour faire un tour complet
rotation=90*sin(360*$t); //pour faire des allers retours
rotate([0,0,rotation])

multmatrix(m = [ [cos(angle), -sin(angle), 0, 0],
                 [sin(angle),  cos(angle), 0, sqrt(2)],
                 [         0,           0, 1, sqrt(2)],
                 [         0,           0, 0,  1]
              ])
scale([0.5,1,1.5])
    repere();
</file>
</ifauth>
=====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
 

<file txt 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);

</file>
 

<ifauth @prof>


</ifauth>
=====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:
{{https://bvdp.inetdoc.net/files/iut/td_openscad/palette_td2.png}}

<ifauth @prof>

alt+Ins pour Wizard

rotation autour du 3eme axe: shift + clic gauche

faire une librairie (fleche et repere vers repere.scad)

include <repere.scad>

    include <filename> acts as if the contents of the included file were written in the including file, and
    use <filename> imports modules and functions, but does not execute any commands other than those definitions.
    

forme 2d (polygon+texte) + extrusion linear_extrude(height,center,convexity,twist,slices)

scale pour le texte

# debug

union()


repere();

translate([0,100,0])

rotate([0,0,atan2(-50,100)])


module piece(jeu=0){...

variable globale resolution=> expliquer modèle pour différentes applications (simu ou impression 3D), mettre valeur petite pour accélérer le rendu pendant la conception
                  expliquer que c'est comme une constante car openscad est un langage fonctionnel, pas procédural: Values cannot be modified during run time;

for imbriqués

if

echo(…)

intersection()et difference()

hull()

minkowski(convexity)

à la toute fin, faire un module suppport avec Z vertical par rapport au plateau


expliquer:
  polyhedron(points, faces, convexity)
  import("….ext", convexity)
  
  
si il y a le temps expliquer script de compilation, 2 rendu avec resolutions différentes

</ifauth>
  
 
====Version faite en TD====
<file txt 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();
</file>



====Version étendue====
<file txt 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();
</file>