2. Conception Assistée par Ordinateur (CAO)#
Dans ce module je présenterai les divers logiciels qui nous ont été montrés et que nous avons utilisé dans le cadre de ce cours. Je montrerai également les pièces que j’ai réalisé à l’aide de ces logiciels en expliquant le processus.
2.1 Inkscape#
Ce premier logiciel appelé Inkscape nous permettra d’effectuer du dessin 2D. Cependant s’il ne s’agissait que de dessin 2D sans particularité nous n’aurions aucune utilité à en parler. En effet, Inkscape est un logiciel permettant de faire du dessin vectoriel, et qui est open source qui plus est.
J’ai écris un tutoriel pour l’utilisation de Inkscape que vous pouvez retrouver ici.
Vectoriel vs matriciel#
Je viens de mentionner le dessin vectoriel, ce qui permet de créer des images un peu “particulières” dans le sens où elles sont différentes des images matricielles que nous utilisons habituellement.
Les images matricielles sont des objets numériques constitués de pixels, ce sont ces pixels qui nous intéressent ici. Un pixel est un tout petit carré de couleur unie, et en les assemblant cela nous permet de créer des images à condition d’avoir des images suffisament grandes. C’est de la que vient la résolution d’une image, elle est déterminée par le nombre de pixels présents, et vous vous doutez bien qu’une image contenant des centaines de millions de pixels sera beaucoup plus nette qu’une image contenant seulement 4 pixels (donc 4 carrés de couleur pour représenter des objets). Le problème avec ces images c’est que nous sommes limités par le nombre de pixels, donc si nous agrandissons l’image nous atteindront la taille des pixels ce qui entrainera une baisse de qualité locale. C’est là que les images vectorielles entrent en jeu.
Les images vectorielles ne sont quand à elles pas composées de pixels mais bien de formes géométriques calculées mathématiquement qui permettent de les étirer ou courber à souhait. Puisqu’il s’agit de formes géométriques entières (déterminées par des vecteurs) et non pas de pixels, nous pouvons agrandir l’image à l’infini sans jamais perdre de qualité localement. Ce sont ces images vectorielles que nous utiliserons pour nos dessins 2d étant donné que les vecteurs qui la composent sont très nets et précis, permettant de créer des lignes et des courbes “parfaites”. De plus les fichiers vectoriels sont généralement moins volumineux que les fichiers matriciels puisqu’ils n’ont pas besoin de stocker autant d’informations que dans la grille complète des pixels d’une d’image.
En résumé, nous utiliserons dans le cadre de ce cours Inkscape pour ses dessins vectoriels, sa gratuité et le fait qu’il soit open source.
2.2 Conception 3D#
Nous venons de voir la partie dessin 2D, nous pouvons maintenant à nous attaquer à la partie concernant la conception d’objet en 3 dimensions. Pour ceci je présenterai deux logiciels et expliquerai le fonctionnement ainsi que la conception de mes pièces sur celui que j’ai utilisé.
FreeCad#
Commençons d’abord par celui que je n’ai pas vraiment utilisé: Freecad.
Freecad est un logiciel de modélisation 3D open source, et son gros point fort est sa conception paramétrique. Nous verrons l’avantage du paramétrique dans la partie suivante, mais ceci nous est d’une très grande aide et permet un énorme gain de temps.
Selon moi FreeCad reste un bon logiciel mais dans le cadre de ce cours je le trouve bien trop complexe à prendre en main pour l’utilisation basique qui en est faite. C’est pourquoi j’ai décidé de travailler sur l’autre logiciel proposé.
OpenSCAD#
J’ai donc choisi de travailler avec OpenSCAD.
OpenSCAD est également un logiciel de modélisation 3D, et celui-ci fonctionne sur base de lignes de codes (pour ceux ayant déjà utilisé MATLAB ou Octave le fonctionnement est très similaire). Son principe est très simple: on ajoute des formes géométriques prédéfinies que l’on peut modififer à souhait, nous pouvons effectuer des opérations sur les formes indépendamment ou entre différentes formes et ainsi créer des pièces finales plus au moins complexes selon le projet. Le point fort d’OpenSCAD est son approche du code (plutôt orienté objet) qui permet d’écrire des modules/fonctions qui sont des sous-parties du code et que nous pouvons réutiliser dans le même code ou l’importer dans d’autres projets. Ceci donne des codes modulaires, et s’il est bien organisé nous pouvons aussi le rendre paramétrique ce qui facilite sa modification. Un point fort est également sa preview qui peut être faite rapidement après les modifications, cela permet de se rendre compte de l’avancée ou des erreurs qui peuvent avoir lieu.
J’ai écris un tutoriel pour vous guider dans votre prise en main de OpenSCAD, vous pouvez le retrouver ici.
Compliant mechanism#
Les compliant mechanism, appelées mécanismes flexibles en français, sont principalement utilisés dans l’ingénierie mécanique. Ces mécanismes utilisent les propriétés du matériau afin de permettre une “élasticité” et une déformation du corps permettant ainsi une transmission de force et de mouvement. Ceux-ci sont généralement fabriqués en une seule pièce et peuvent, suivant les utilités, être assemblés avec différentes pièces pour créer un système plus complexe. L’un des exemples le plus connu et le plus ancien est l’arc avec sa corde, il permet de tirer des flèches en jouant sur la rigidité des branches.
Vous retrouverez ci-dessous une petite vidéo (en anglais mais les sous-titres français sont disponibles) explicative sur ces mécanismes avec des exemples de mécanismes et leurs utilisations:
Conception#
Maintenant que nous savons ce que sont ces mécanismes flexibles, nous avons dû en concevoir dans le cadre de ce cours. Ceci à principalement servi à prendre en main le logiciel que nous avons choisi (dans mon cas il s’agit d’OpenSCAD) afin de nous familiariser avec et de pouvoir l’utiliser par la suite dans la conception et l’impression des futures pièces.
Pièce 1#
Voici un aperçu de la première pièce réalisée:
Afin de créer cette pièce sur OpenSCAD j’ai écris le code suivant:
/*
Auteur: Bilba Christopher
Licence: Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
*/
// Paramètres
$fn = 100;
hauteur = 6;
rayon = 2.5;
epaisseur = 0.7;
longueur = 40;
largeur = 1.5;
module tete(){
difference(){
hull(){
cylinder(h = hauteur, r = rayon+epaisseur);
translate([8,0,0]){cylinder(h = hauteur, r = rayon+epaisseur);}
}
for (i = [1:2]){
translate([(i-1)*8,0,0]){
cylinder(h = hauteur, r = rayon);
}
}
}
}
module tige(){
translate([-longueur-rayon-epaisseur, -largeur/2,0]){
cube([longueur,largeur,hauteur]);
}
}
module main(){
tete();
translate([-8-(2*rayon)-(2*epaisseur)-longueur,0,0]){
tete();
}
tige();
}
main();
Nous y retrouvons en premier un en-tête reprenant le nom de l’auteur (en l’occurrence le mien) ainsi que la licence apposée sur la création (nous verrons cela au prochain point).
Viennent ensuite les paramètres qui eux sont très importants. Ils nous permettent de modifier la pièce en changeant sa taille et sa résolution dans notre cas, mais uniquement en changeant les paramètres du début. Ceci nous évite de devoir modifier le code pour changer les valeurs une a une, à condition que le code soit bien écrit. Je rappelle qu’ici j’expliquerai simplement comment j’ai réalisé ma pièce, un tutoriel OpenSCAD est disponible.
Dans ce code j’ai écris 3 modules, regardons de plus près ce que chacun d’entre eux permet.
Le premier est le module tete(), celui-ci nous permet de créer une des extrémités de la pièce. Il s’agit tout simplement d’un cylindre dans lequel nous faisons apparaître 2 autres cylindres afin d’en effectuer la différence et donc d’y placer les trous. En voici le résultat:
Le deuxième module tige(), permet de créer une tige aux bonnes dimensions entre les deux têtes en utilisant les paramètres de départ. Ce qui nous donne en somme un simple rectangle aux bonnes dimensions:
Et enfin le dernier module main() est simplement le module principal appelant tout les modules de la bonne manière avec les bonnes translations afin de générer les 3 parties de la pièce et de les placer au même endroit. Voici donc le résultat final:
Pièce 2#
Cette seconde pièce plus complexe a été en réalité la première pièce que j’ai conçue mais qui s’est soldée par un échec. Le but était d’arriver à faire une sorte de mousqueton sur base d’un ressort et d’une structure, le design qui nous a servi de référence est (fichier de ALECS_FORM):
Voici la pièce que j’ai cherché à faire pour la partie du ressort:
Le code que j’ai utilisé sur OpenSCAD pour la conception de cette pièce est le suivant:
/*
Auteur: BILBA Christopher
Licence: Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
*/
//Paramètres du ressort
Radius= 2.5; //Rayon du ressort
Wire_radius=0.3; //Rayon du fil
Pitch= 2; //Distance entre deux spires
Coils = 7; //Nombre de spires
$fn= 20; //Résolution
function m_translate(v) = [ [1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[v.x, v.y, v.z, 1 ] ];
function m_rotate(v) = [ [1, 0, 0, 0],
[0, cos(v.x), sin(v.x), 0],
[0, -sin(v.x), cos(v.x), 0],
[0, 0, 0, 1] ]
* [ [ cos(v.y), 0, -sin(v.y), 0],
[0, 1, 0, 0],
[ sin(v.y), 0, cos(v.y), 0],
[0, 0, 0, 1] ]
* [ [ cos(v.z), sin(v.z), 0, 0],
[-sin(v.z), cos(v.z), 0, 0],
[ 0, 0, 1, 0],
[ 0, 0, 0, 1] ];
function vec3(v) = [v.x, v.y, v.z];
function transform(v, m) = vec3([v.x, v.y, v.z, 1] * m);
function orientate(p0, p) =
m_rotate([0, atan2(sqrt(pow(p[0], 2) + pow(p[1], 2)), p[2]), 0])
* m_rotate([0, 0, atan2(p[1], p[0])])
* m_translate(p0);
function circle_points(r = 1, a = 0) =
a < 360
? concat([[r * sin(a), r * cos(a),0]], circle_points(r, a + 360 / $fn))
: [] ;
function loop_points(step, end , t = 0) =
t <= end
? concat([f(t)], loop_points(step, end, t + step))
: [] ;
function transform_points(list, matrix, i = 0) =
i < len(list)
? concat([ transform(list[i], matrix) ], transform_points(list, matrix, i + 1))
: [];
function tube_points(loop_points, section_points, i=0) =
i < len(loop_points)-1
? concat(
transform_points(
section_points,
orientate(loop_points[i],(loop_points[i + 1]- loop_points[i])/2)),
tube_points(loop_points,section_points, i + 1)
)
: [] // in a closed loop, this segment connects to the start
;
function tube_faces(facets, s, i = 0) =
i < facets
? concat([[s * facets + i,
s * facets + (i + 1) % facets,
(s + 1) * facets + (i + 1) % facets,
(s + 1) * facets + i]
],
tube_faces(facets, s, i + 1))
: [];
function tube_end(facets, s, i = 0) =
i < facets
? concat( [s * facets + i], tube_end(facets, s, i+1))
: [];
function loop_faces(segs,facets, j = 0) =
j < segs
? concat(tube_faces(facets, j), loop_faces(segs, facets, j + 1))
: [];
function loop_all_faces(segs,facets) =
concat ([reverse(tube_end(facets,0))], // direction changed here
loop_faces(segs,facets),
[tube_end(facets,segs)]
);
function reverse_r(v,n) =
n == 0
? [v[0]]
: concat([v[n]],reverse_r(v,n-1))
;
function reverse(v) = reverse_r(v, len(v)-1);
function circle_points(r = 1, a = 0) =
a < 360
? concat([[r * sin(a), r * cos(a),0]], circle_points(r, a + 360 / $fn))
: [] ;
function f(t) = [Radius *sin(t),Radius * cos(t) ,Pitch * t/360 ];
function loop_points(step, end, t = 0) =
t <= end
? concat([f(t)], loop_points(step, end, t + step ))
: [] ;
section_points = circle_points(Wire_radius, 360/$fn);
loop_points = loop_points(3 ,360* Coils + 3);
tube_points = tube_points(loop_points,section_points);
faces = loop_all_faces(len(loop_points)-2, len(section_points));
polyhedron(points = tube_points, faces = faces);
translate([0, Radius, 0]) {
cube([2, 2, Wire_radius*4], center = true);
}
translate([0, Radius, Pitch*Coils]) {
cube([2, 2, Wire_radius*4], center = true);
}
2.3 Licences#
Maintenant que nous avons fini un travail, nous pouvons nous attaquer aux licences afin d’en comprendre leurs utilités et ensuite d’apprendre à les utiliser correctement selon les besoins de chacun.
Utilité#
Les licences servent à appliquer des droits d’auteurs sur toute création. Ceci permet à l’auteur d’une certaine création de posséder des droits sur cette création, droits qu’il peut éventuellement céder à d’autres personnes. Donc dans le principe, ceci vous permet de “sécuriser” votre travail en y imposant diverses conditions que vous choisissez.
Les différentes licences#
Dans ce cadres-ci nous parlerons uniquement des licences Creative Commons (CC) bien qu’il en existe d’autres, mais celles-ci étant les plus répandues leur utilisation sera bien plus aisée. Voici les 6 licences CC:
- CC-BY: Creative Commons Attribution autorise tout le monde à distribuer, retravailler et/ou adapter le travail original sous n’importe quelle forme tant que l’auteur est cité.
- CC BY-SA Creative Commons Attribution-ShareALike autorise tout le monde à distribuer, retravailler et/ou adapter le travail original sous n’importe quelle forme tant que l’auteur est cité et sous la condition que le travail est soumis à la licence identique.
- CC BY-NC Creative Commons Attribution-NonCommercial autorise tout le monde à distribuer, retravailler et/ou adapter le travail original sous n’importe quelle forme tant que l’auteur est cité mais il ne permet pas d’utiliser le travail original à des fins commerciales.
- CC BY-NC-SA Creative Commons Attribution-ShareALike-NonCommercial autorise tout le monde à distribuer, retravailler et/ou adapter le travail original sous n’importe quelle forme tant que l’auteur est cité et sous la condition que le travail est soumis à la licence identique, et ceci à des fins non-commerciales uniquement.
- CC BY-ND Creative Commons Attribution-NoDerivatives autorise tout le monde à copier et distribuer le travail original sous n’importe quelle forme tant que l’auteur est cité et qu’aucune adaptation ou retravail n’a été effectué.
- CC BY-NC-ND Creative Commons Attribution-NoDerivatives autorise tout le monde à copier et distribuer le travail original sous n’importe quelle forme tant que l’auteur est cité et qu’aucune adaptation ou retravail n’a été effectué, ceci à des fins non-commerciales seulement.
Protection des travaux#
Afin d’appliquer une licence CC sur votre trvail, il vous suffit tout simplement de choisir la licence qui correspond à ce que vous attendez de votre travail et de le communiquer d’une manière à ce que toute personnes voyant votre travail comprenne quelle utilisation peut en être faite. Dans le script OpenSCAD par exemple, il vous suffit de mettre un en-tête en commentaire en précisant vos informations et en indiquant explicitement la licence CC appliquée.
Voilà vous pouvez désormais appliquer une licence CC à vos travaux finis, si vous souhaitez des informations supplémentaires je vous invite à rechercher les rechercher par vous-même. La plupart des information nécessaires sont disponibles ici: