1 - Introduzione

OpenSCAD è un software CAD 3D open source che utilizza un approccio di modellazione basato su codice invece che su interfaccia grafica interattiva 。L'utente scrive uno script testuale che descrive il modello 3D, e OpenSCAD genera la geometria da quel codice 。Questo metodo offre controllo completo sul processo di modellazione e permette di creare facilmente progetti parametrici modificabili 。

OpenSCAD supporta due tecniche principali di modellazione: la geometria solida costruttiva (CSG) e l'estrusione di profili 2D 。L'uso principale è la progettazione di modelli per la stampa 3D, grazie alla capacità di creare design parametrici riutilizzabili e personalizzabili 。

1.1 - Installazione

Sito Ufficiale: https://www.openscad.org

Download Snapshots: https://openscad.org/downloads.html#snapshots

Utilizzare il file .exe per l'installazione ed seguire le istruzioni senza variare nulla.

Nota:

Per eseguire OpenSCAD in versione sviluppo il programma richiede le librerie per funzionare che si trovano in questo link:

• Visual c++ runtime:

https://learn.microsoft.com/it-it/cpp/windows/latest-supported-vc-redist?view=msvc-170

Installare in sequenza:

• vc_redist.x86.exe

• vc_redist.x64.exe

2 - Configurazione

Dopo aver avviato il programma, è necessario configurare le preferenze per ottimizzare l'esperienza d'uso: si inizia cliccando su "Non mostrare più" e "Nuovo", poi si allarga la finestra e si attiva "Ricarica automatica con anteprima" dal menu Progetto, quindi si accede a "Modifica > Preferenze" per regolare le impostazioni. Nella sezione Vista 3D si cambia il tema in ClearSky e si deseleziona "Mostra notifiche e Errori nella vista 3D". Nella sezione Editor si cambia la dimensione carattere da 12 a 14 per migliorare la leggibilità. Nella sezione Experimental si attiva textmetrics. Nella sezione Stampa 3D non è richiesta nessuna modifica. Nella sezione Avanzate si aumenta la Resa 3D da 100000 a 10000000 per permettere mesh più complesse, si seleziona il Backend Manifold (new/fast) che è un motore geometrico moderno e performante (nelle ultime versioni è già impostato predefinito), si aumentano la Cache CGAL e la Cache PolySet da 100 a 1000, si deseleziona "Carica Localizzazione interfaccia Utente (Richiede riavvio di OpenSCAD)" e si attiva "Enable undocking of helper widgets to separate windows". Le sezioni Assi, Tasti e Dialogs non richiedono modifiche. Nella sezione Mouse si imposta il preset da "OpenSCAD" a "Blender". OpenSCAD dopo il riavvio si presenta in lingua inglese, giusto per usarlo ed impararlo ad usare in inglese vedendo altri tutorial etc. su internet essendo 90% materiale in inglese.

3 - Panoramica

3.1 - Scheda Editor

L'Editor è l'area principale dove si scrive il codice OpenSCAD. Supporta evidenziazione della sintassi, completamento automatico e visualizzazione degli errori direttamente nel codice 。Ogni file aperto appare come una scheda separata, permettendo di lavorare su più progetti contemporaneamente 。

3.2 - Scheda Console

La Console mostra i messaggi di output, i risultati delle valutazioni e le informazioni di debug. Visualizza ciò che viene stampato tramite il comando echo() e altri messaggi generati durante l'esecuzione del codice 。

3.3 - Scheda Errors

La scheda Errors cattura e visualizza gli errori di sintassi e runtime. Evidenzia la riga specifica dove si è verificato il problema, facilitando la correzione del codice 。

3.4 - Scheda Viewport 3D

Il Viewport 3D mostra l'anteprima del modello generato. Permette di ruotare, spostare e zoomare la vista per esaminare il modello da diverse angolazioni 。La vista viene aggiornata premendo F5 (anteprima) o F6 (render completo) 。

3.5 - Scheda Customizer (Configuratore)

Il Customizer analizza il codice e genera automaticamente controlli UI (slider, caselle di spunta, menu) basandosi sui commenti speciali nel codice sorgente 。Permette di modificare i parametri del modello senza toccare il codice.

4 - Tastiera e Mouse

4.1 - Tastiera

F5

Esegue l'anteprima del modello. Visualizzazione rapida della geometria senza calcoli complessi.

F6

Esegue il render completo (Render). Calcola la geometria finale con tutte le operazioni CSG.

F7

Esporta come STL. Salva il modello renderizzato in formato STL per la stampa 3D.

F9

Attiva o disattiva l'anteprima (Preview).

F12

Esegue il render completo (Thrown Together).

Ctrl+1

Mostra o nasconde i bordi (Show Edges).

Ctrl+2

Mostra o nasconde gli assi (Show Axes).

Ctrl+3

Mostra o nasconde i marcatori di scala (Show Scale Markers).

Ctrl+4

Vista dall'alto (Top).

Ctrl+5

Vista dal basso (Bottom).

Ctrl+6

Vista laterale sinistra (Left).

Ctrl+7

Vista laterale destra (Right).

Ctrl+8

Vista frontale (Front).

Ctrl+9

Vista posteriore (Back).

Ctrl+0

Vista diagonale (Diagonal).

Ctrl+Shift+0

Vista centrata (Center).

Ctrl+Shift+V

Visualizza tutto (View All).

Ctrl+]

Zoom avanti (Zoom In).

Ctrl+[

Zoom indietro (Zoom Out).

4.2 - Mouse

Preset: Blender 3D

Configurazione dei controlli mouse per navigare il viewport 3D in modo simile al software Blender:

• Rotazione: trascinare con il tasto sinistro del mouse.
• Spostamento: trascinare con il tasto destro del mouse.
• Zoom: rotellina del mouse.

5 - Operatori

5.1 - Matematici

• + Addizione
• - Sottrazione
• * Moltiplicazione
• / Divisione
• % Modulo (resto della divisione)
• ^ Elevamento a potenza

a = 10 + 5;    // 15
b = 20 - 8;    // 12
c = 4 * 3;     // 12
d = 15 / 3;    // 5
e = 17 % 5;    // 2
f = 2 ^ 3;     // 8
echo(a, b, c, d, e, f);

5.2 - Logici

• && AND logico (vero se entrambi veri)
• || OR logico (vero se almeno uno vero)
• ! NOT logico (nega il valore)

x = true;
y = false;
echo(x && y);  // false
echo(x || y);  // true
echo(!x);      // false

5.3 - Confronto

• == Uguale a
• != Diverso da
• < Minore di
• > Maggiore di
• <= Minore o uguale
• >= Maggiore o uguale

a = 10;
b = 20;
echo(a == b);  // false
echo(a != b);  // true
echo(a < b);   // true
echo(a > b);   // false
echo(a <= 10); // true
echo(b >= 20); // true

5.4 - Operatore Ternario

$fn = $preview ? 32 : 128;
sphere(d=20);

• $preview è true durante l'anteprima (F5)
• $preview è false durante il render (F6)
• ? separa la condizione dal valore se vero
• : separa il valore se vero dal valore se falso

In anteprima (F5): $fn = 32
In render (F6): $fn = 128

6 - Commenti

6.1 - Multilinea

/* Questo è un commento
   su più righe.
   Tutto ciò che è compreso
   tra /* e */ viene ignorato */

I commenti multilinea iniziano con /* e terminano con */. Tutto il testo compreso tra questi delimitatori viene ignorato dal compilatore 。

6.2 - Singola Riga

// Questo è un commento su una singola riga
cube(10); // Commento dopo il codice

I commenti su singola riga iniziano con //. Tutto il testo dalla posizione di // fino alla fine della riga viene ignorato 。

7 - Variabili

7.1 - Interi

lato = 20;
cube(lato);

Un valore intero viene assegnato alla variabile lato.

7.2 - Decimali

cerchio = 2.5;
circle(r=cerchio);

Valori con parte decimale vengono usati per dimensioni precise.

7.3 - Stringhe

nome = "Luigi";
echo(nome);

Le stringhe sono sequenze di caratteri racchiuse tra virgolette doppie.

7.4 - Vettori

size = [30,50,10];
cube(size);

I vettori sono liste di valori racchiuse tra parentesi quadre.

8 - Costanti

8.1 - undef

x = undef;

undef rappresenta un valore non definito o nullo. Viene usato per inizializzare variabili senza un valore specifico.

8.2 - PI

circle(r=PI);

PI è la costante matematica π (pi greco), approssimativamente 3.14159.

9 - Variabili Speciali

9.1 - $fs (Minimum Size)

Definisce la dimensione minima di un frammento per le curve. Valori più piccoli producono curve più fluide ma aumentano il numero di frammenti.

9.2 - $fa (Minimum Angle)

Definisce l'angolo minimo per i frammenti delle curve. Controlla la risoluzione angolare della geometria curva.

9.3 - $fn (Number of Fragments)

Definisce il numero di frammenti per le curve.

circle(r=20, $fn=6); // Crea esagono

circle(r=20, $fn=3); // Crea triangolo

9.4 - $children

module conta_figli() {
    echo("Numero di figli: ", $children);
    children();
}

conta_figli() {
    cube(5);
    sphere(3);
    cylinder(r=2, h=4);
}
// Output: Numero di figli: 3

$children contiene il numero di figli passati a un modulo.

9.5 - $preview

$fn = $preview ? 32 : 128;
sphere(d=20);

$preview è true durante l'anteprima (F5) e false durante il render completo (F6). Permette di usare risoluzioni diverse per le due modalità.

10 - Oggetti 2D

10.1 - circle

Opzioni:

• r - raggio del cerchio
• d - diametro del cerchio
• $fn - numero di frammenti

circle(r=10);

circle(d=30);

circle(r=5, $fn=100);

Crea un cerchio 2D nel piano XY. Il centro è nell'origine.

10.2 - square

Opzioni:

• size - dimensione (singolo valore per quadrato, vettore [x,y] per rettangolo)
• center - se true, centra il quadrato nell'origine

square(20);

square([30, 50]);

square(20, center=true);

square([30, 50], center=true);

Crea un quadrato o rettangolo 2D.

10.3 - polygon (Triangolo)

Opzioni:

• points - lista di coordinate [x,y] dei vertici
• paths - lista di percorsi per connettere i punti

polygon(points=[[0,0], [20,0], [10,15]]);

Crea un triangolo con vertici specificati.

10.4 - polygon + path (Quadrato con foro)

Opzioni:

• points - lista di tutti i vertici
• paths - lista di percorsi che definiscono i contorni

polygon(
    points=[[0,0], [20,0], [20,20], [0,20], [5,5], [15,5], [15,15], [5,15]],
    paths=[[0,1,2,3], [4,5,6,7]]
);

Crea un quadrato con un foro quadrato interno. Il primo path definisce il contorno esterno, il secondo il contorno interno.

10.5 - text

Opzioni:

• text - stringa di testo da visualizzare
• size - altezza del testo
• font - nome del font
• halign - allineamento orizzontale (left, center, right)
• valign - allineamento verticale (top, center, baseline, bottom)
• spacing - spaziatura tra le lettere
• direction - direzione del testo (ltr, rtl, ttb, btt)

text("Ciao", size=10);

text("Centro", size=10, halign="center", valign="center");

text("OpenSCAD", size=8, font="Arial:style=Bold");

halign controlla l'allineamento orizzontale: left (sinistra), center (centro), right (destra).
valign controlla l'allineamento verticale: top (alto), center (centro), baseline (linea base), bottom (basso).

11 - Estrusioni

11.1 - linear_extrude

Opzioni:

• height - altezza dell'estrusione
• center - se true, centra l'estrusione sull'asse Z
• convexity - valore per il rendering corretto
• twist - rotazione durante l'estrusione
• slices - numero di slice per la torsione
• scale - fattore di scala alla fine dell'estrusione

linear_extrude(height=10) {
    circle(r=5);
}

linear_extrude(height=20, center=true, twist=90, slices=50) {
    square(10, center=true);
}

linear_extrude(height=15, scale=0.5) {
    square(20, center=true);
}

Trasforma un oggetto 2D in 3D estrudendolo lungo l'asse Z.

11.2 - rotate_extrude

Opzioni:

• angle - angolo di rotazione (default 360)
• convexity - valore per il rendering
• $fn - numero di frammenti

rotate_extrude() {
    translate([10, 0, 0]) {
        circle(r=3);
    }
}

rotate_extrude(angle=180, $fn=100) {
    translate([15, 0, 0]) {
        square([5, 10]);
    }
}

Ruota un profilo 2D attorno all'asse Z per creare un oggetto 3D. Il profilo deve essere completamente sul lato positivo dell'asse X. La funzione translate sposta il profilo 2D prima della rotazione.

12 - Oggetti 3D

12.1 - cube

Opzioni:

• size - dimensione (singolo valore o vettore [x,y,z])
• center - se true, centra il cubo nell'origine

cube(20);

cube([30, 50, 10]);

cube(20, center=true);

cube([30, 50, 10], center=true);

Crea un cubo o parallelepipedo 3D.

12.2 - sphere

Opzioni:

• r - raggio della sfera
• d - diametro della sfera
• $fn - numero di frammenti

sphere(r=10);

sphere(d=25);

sphere(r=5, $fn=100);

Crea una sfera centrata nell'origine.

12.3 - cylinder

Opzioni:

• h - altezza del cilindro
• r - raggio (singolo valore o vettore [r1, r2] per cono)
• r1 - raggio inferiore
• r2 - raggio superiore
• d - diametro
• d1 - diametro inferiore
• d2 - diametro superiore
• center - se true, centra sull'asse Z
• $fn - numero di frammenti

cylinder(h=20, r=5);

cylinder(h=20, r1=5, r2=2);

cylinder(h=20, d=10);

cylinder(h=20, d1=10, d2=4);

cylinder(h=20, r=5, center=true);

Crea un cilindro o cono. Il centro della base è nell'origine (o al centro se center=true).

12.4 - polyhedron

Opzioni:

• points - lista di coordinate [x,y,z] dei vertici
• faces - lista di facce, ogni faccia è una lista di indici dei vertici
• convexity - valore per il rendering

polyhedron(
    points=[
        [0,0,0], [10,0,0], [10,10,0], [0,10,0],
        [0,0,10], [10,0,10], [10,10,10], [0,10,10]
    ],
    faces=[
        [0,1,2,3],
        [4,5,1,0],
        [7,6,5,4],
        [5,6,2,1],
        [6,7,3,2],
        [7,4,0,3]
    ]
);

Crea un poliedro personalizzato specificando vertici e facce. Gli indici delle facce devono essere in ordine orario quando visti dall'esterno.

13 - Trasformazioni

13.1 - translate

Opzioni:

• v - vettore di traslazione [x, y, z]

translate([10, 20, 30]) {
    cube(5);
}

translate([0, 0, 15]) {
    sphere(10);
}

Sposta l'oggetto figlio della quantità specificata lungo gli assi X, Y e Z.

13.2 - rotate

Opzioni:

• a - angolo di rotazione (singolo valore per rotazione attorno a Z)
• v - vettore degli angoli di rotazione [x, y, z]

rotate([0, 0, 45]) {
    cube(10);
}

rotate(90) {
    cylinder(h=20, r=5);
}

rotate([45, 45, 0]) {
    cube([10, 10, 10], center=true);
}

Ruota l'oggetto figlio. La rotazione avviene nell'ordine X, Y, Z.

13.3 - scale

Opzioni:

• v - vettore di scala [x, y, z]

scale([2, 1, 1]) {
    sphere(10);
}

scale([1, 2, 3]) {
    cube(10);
}

Scala l'oggetto figlio di fattori specificati lungo ciascun asse.

13.4 - mirror

Opzioni:

• v - vettore normale al piano di riflessione

mirror([1, 0, 0]) {
    cube([10, 20, 30]);
}

mirror([0, 0, 1]) {
    cylinder(h=10, r=5);
}

Riflette l'oggetto figlio rispetto al piano definito dal vettore normale.

13.5 - resize

Opzioni:

• newsize - nuove dimensioni [x, y, z]
• auto - specifica quali dimensioni calcolare automaticamente (true/false o vettore)

resize([20, 30, 40]) {
    sphere(10);
}

resize([20, 0, 0]) {
    cube([10, 20, 30]);
}

resize([20, 30, 0], auto=[true, true, false]) {
    cube(10);
}

Ridimensiona l'oggetto figlio alle dimensioni specificate. auto permette di calcolare automaticamente alcune dimensioni mantenendo le proporzioni.

13.6 - offset

Opzioni:

• r - raggio di offset (positivo espande, negativo contrae)
• delta - offset con angoli smussati
• chamfer - se true, usa chamfer invece di round

offset(r=2) {
    square(20, center=true);
}

offset(delta=3) {
    circle(r=10);
}

Espande o contrae un oggetto 2D di una quantità specificata.

13.7 - offset con chamfer

Opzioni:

• delta - quantità di offset
• chamfer - se true, crea smussi invece di curve

offset(delta=2, chamfer=true) {
    square(20, center=true);
}

Crea un offset con angoli smussati (chamfer) invece che arrotondati.

13.8 - projection

Opzioni:

• cut - se true, proietta una sezione trasversale invece dell'intero oggetto.

Download del file STL di esempio: https://raw.githubusercontent.com/CreativeTools/3DBenchy/master/Single-part/3DBenchy.stl

projection(cut = false) {
    rotate([-90, 0, 0]) {
        import("3DBenchy.stl");
    }
}

Crea una proiezione 2D di un oggetto 3D. Con cut=true crea una sezione trasversale.

13.9 - multmatrix

Opzioni:

• m - matrice 4x4 che definisce la trasformazione affine da applicare.

multmatrix(m = [
    [1, 0, 0, 20],
    [0, 1, 0, 10],
    [0, 0, 1, 5],
    [0, 0, 0, 1]
]) {
    cube(10);
}

Applica una trasformazione definita da una matrice 4x4 all'oggetto figlio. La matrice è composta da 4 liste di 4 valori: le prime tre colonne definiscono rispettivamente rotazione, scala e shear sugli assi X, Y, Z, mentre la quarta colonna definisce la traslazione [x, y, z]. L'ultima riga è normalmente [0, 0, 0, 1].

Nell'esempio, il cubo di lato 10 viene traslato di 20 lungo X, 10 lungo Y e 5 lungo Z.

14 - Trasformazioni Avanzate

14.1 - hull

raggio = 5;
distanza = 20;
altezza = 3;

linear_extrude(height = altezza) {
    hull() {
        circle(r = raggio, $fn = 100);
        translate([distanza, 0, 0]) {
            circle(r = raggio, $fn = 100);
        }
    }
}

hull() crea il guscio convesso che racchiude tutti gli oggetti figli. Nell'esempio crea un'asola 2D estrusa.

14.2 - minkowski

larghezza = 40;
profondita = 30;
altezza = 20;
raggio_smussatura = 4;

minkowski() {
    cube([
        larghezza - (raggio_smussatura * 2),
        profondita - (raggio_smussatura * 2),
        altezza - (raggio_smussatura * 2)
    ], center = true);
    sphere(r = raggio_smussatura, $fn = 50);
}

minkowski() somma le dimensioni degli oggetti. Il cubo viene ridotto per compensare l'espansione della sfera, ottenendo un cubo smussato delle dimensioni desiderate.

15 - Operazioni Booleane (CSG)

15.1 - union

union() {
    cube(10, center=true);
    sphere(8);
}

Unisce tutti gli oggetti figli in un unico solido.

15.2 - difference

difference() {
    cube(20, center=true);
    sphere(12);
}

Sottrae gli oggetti successivi dal primo oggetto.

15.3 - intersection

intersection() {
    cube(15, center=true);
    sphere(10);
}

Mantiene solo la parte comune a tutti gli oggetti.

16 - Cicli

16.1 - for (Struttura base)

for (i = [0:5]) {
    translate([i * 15, 0, 0]) {
        cube(10);
    }
}

Il ciclo for itera su un intervallo di valori.

16.2 - Griglia 3x3

for (x = [0:2]) {
    for (y = [0:2]) {
        translate([x * 20, y * 20, 0]) {
            cube(10);
        }
    }
}

Cicli annidati per creare una griglia di oggetti.

16.3 - Cerchio di cilindri

for (i = [0:11]) {
    rotate([0, 0, i * 30]) {
        translate([30, 0, 0]) {
            cylinder(h=20, r=5);
        }
    }
}

Crea 12 cilindri disposti in cerchio.

16.4 - intersection_for

intersection_for(n = [1 : 6]) {
    rotate([0, 0, n * 60]) {
        translate([10, 0, 0]) {
            sphere(r = 15);
        }
    }
}

intersection_for calcola l'intersezione di tutte le iterazioni del ciclo.

17 - Colori

17.1 - Colore con nome

color("red") {
    cube(10);
}

I colori con nome più comuni: red, green, blue, yellow, cyan, magenta, black, white, orange, purple, pink, gray, brown.

17.2 - Colore RGB

color([1, 0, 0]) {
    cube(10);
}

color([0.5, 0.5, 0.5]) {
    sphere(5);
}

I valori RGB vanno da 0 a 1.

17.3 - Colore RGBA

color([1, 0, 0, 0.5]) {
    cube(10);
}

Il quarto valore è l'alpha (trasparenza), da 0 (trasparente) a 1 (opaco).

18 - Modificatori

18.1 - *

*cube([10, 10, 10], center=true);

Disattiva completamente il sottoalbero. Il nodo e tutti i suoi figli vengono ignorati.

18.2 - !

!cylinder(r=2, h=20, center=true);

Rende questo sottoalbero la radice del design. Il resto del modello viene ignorato.

18.3 - #

#cube([10, 10, 10], center=true);

Usa il sottoalbero normalmente ma lo disegna anche in rosa trasparente per il debug.

18.4 - %

%difference() {
    cylinder(h=12, r=5, center=true, $fn=100);
    cylinder(h=15, r=1, center=true, $fn=100);
}

Ignora il sottoalbero nel processo di rendering normale e lo disegna in grigio trasparente.

19 - Prendere Decisioni

x = 10;
x <= 10;
x >= 10;
x == 10;

19.1 - if

x = 10;
if (x > 10) {
    echo("maggiore di 10");
}

Esegue il blocco se la condizione è vera.

19.2 - else if

x = 10;
if (x > 10) {
    echo("maggiore");
} else if (x == 10) {
    echo("uguale");
} else if (x < 10) {
    echo("minore");
}

Verifica condizioni multiple in sequenza.

19.3 - else e controllo tipo

x = 10;
if (is_num(x)) {
    echo("è un numero");
} else {
    echo("non è un numero");
}

is_num() verifica se il valore è un numero.

20 - Moduli

20.1 - Rounded Box

module rounded_box(size = [50, 30, 20], r = 4, center = false) {
    x = size[0];
    y = size[1];
    z = size[2];
    
    shift = center ? [0, 0, 0] : [x/2, y/2, z/2];
    
    translate(shift) {
        minkowski() {
            cube([x - 2*r, y - 2*r, z - 2*r], center=true);
            sphere(r);
        }
    }
}

rounded_box(size = [50, 30, 20], r = 4, center = true, $fn = 32);

Crea un cubo con angoli smussati utilizzando minkowski(). Il parametro size è un vettore [x, y, z] che definisce le dimensioni del box, r è il raggio di smussatura, center determina se il box è centrato nell'origine.

20.2 - Rounded Cylinder

module rounded_cylinder(h = 40, r = 15, rnd = 3, center = false) {
    shift = center ? 0 : h/2;
    
    translate([0, 0, shift]) {
        minkowski() {
            cylinder(h = h - 2*rnd, r = r - rnd, center = true);
            sphere(r = rnd);
        }
    }
}

rounded_cylinder(h = 40, r = 15, rnd = 3, center = false, $fn = 64);

Crea un cilindro con bordi arrotondati utilizzando minkowski(). Il parametro h definisce l'altezza totale, r il raggio, rnd il raggio di arrotondamento dei bordi, center determina se il cilindro è centrato sull'asse Z. Il cilindro interno viene ridotto di rnd sul raggio e di 2*rnd sull'altezza per compensare l'espansione della sfera.

21 - Funzioni

21.1 - Funzioni semplici

function somma(a, b) = a + b;

function quadrato(x) = x * x;

echo(somma(5, 3));
echo(quadrato(4));

Le funzioni restituiscono un valore e possono essere usate nelle espressioni.

21.2 - Funzioni Matematiche

Funzioni più usate:

• sin(x), cos(x), tan(x) - funzioni trigonometriche (x in gradi)
• asin(x), acos(x), atan(x), atan2(y, x) - funzioni trigonometriche inverse
• abs(x) - valore assoluto
• floor(x) - arrotonda per difetto
• ceil(x) - arrotonda per eccesso
• round(x) - arrotonda al più vicino
• sqrt(x) - radice quadrata
• pow(x, y) - potenza
• min(a, b, ...), max(a, b, ...) - minimo e massimo
• exp(x), ln(x), log(x) - esponenziale e logaritmi

21.3 - Funzioni di Tipo (is_*)

• is_undef(x) - vero se il valore è undef
• is_bool(x) - vero se il valore è booleano
• is_num(x) - vero se il valore è numerico
• is_string(x) - vero se il valore è una stringa
• is_list(x) - vero se il valore è una lista
• is_function(x) - vero se il valore è una funzione
• is_object(x) - vero se il valore è un oggetto

21.4 - Esempio: Cuore Matematico

// FUNZIONI MATEMATICHE
function heart_x(t) = 16 * pow(sin(t), 3);
function heart_y(t) = 13 * cos(t) - 5 * cos(2*t) - 2 * cos(3*t) - cos(4*t);

// GENERAZIONE DELL'OGGETTO
resize([60, 60, 10]) {
    linear_extrude(height = 10, center = true, convexity = 10) {
        scale([2, 2]) {
            polygon(points = [
                for (t = [0 : 5 : 360]) 
                    [ heart_x(t), heart_y(t) ]
            ]);
        }
    }
}

Genera un cuore usando equazioni parametriche.

22 - Inclusioni di File SCAD

File: luigiamorfini.scad

22.1 - use

use <luigiamorfini.scad>

Importa solo moduli e funzioni dal file specificato.

22.2 - include

include <luigiamorfini.scad>

Include l'intero contenuto del file nel codice corrente.

22.3 - use vs include

use importa solo definizioni di moduli e funzioni. include inserisce tutto il codice come se fosse scritto direttamente nel file corrente.

23 - Scheda "Console Log"

23.1 - echo / str

23.1.1 - echo

echo("Benvenuto in OpenSCAD");

Stampa un messaggio nella console.

23.1.2 - str

echo(str(...));

Converte valori in stringhe.

23.1.3 - Conversioni di Tipi

echo("Il valore è: ", 42);

Numeri e altri tipi vengono automaticamente convertiti in stringhe.

23.1.4 - Concatenazioni

echo(str("Il valore è: ", 42));

str() concatena stringhe e valori.

23.1.5 - Valori Multipli

a = 5;
b = 10;
echo("Valori:", a, b);

Più valori separati da virgola vengono stampati in sequenza.

23.1.6 - Operazioni

a = 5;
b = 10;
echo(str("Somma: ", a + b));
echo(str("Sottrazione: ", a - b));

Operazioni matematiche all'interno di echo.

24 - File SVG

Consigliato: https://www.inkscape.org

24.1 - import

import("disegno.svg");

Importa un file SVG come oggetto 2D.

24.1.1 - Layer

import("disegno.svg", layer = "Livello 1");

Importa un layer specifico dal file SVG.

24.2 - linear_extrude

linear_extrude(height = 10) {
    import("disegno.svg");
}

Estrude il contenuto SVG importato in 3D.

24.3 - rotate_extrude

rotate_extrude() {
    translate([10, 0, 0]) {
        import("profilo.svg");
    }
}

Ruota il profilo SVG importato attorno all'asse Z. La funzione translate sposta il profilo prima della rotazione.

25 - File DXF

Consigliato: https://www.librecad.org

25.1 - import

import("disegno.dxf");

Importa un file DXF come oggetto 2D.

25.1.1 - Layer

import("disegno.dxf", layer = "Livello 1");

Importa un layer specifico dal file DXF.

25.2 - linear_extrude

linear_extrude(height = 15) {
    import("disegno.dxf");
}

Estrude il contenuto DXF importato in 3D.

25.3 - rotate_extrude

rotate_extrude() {
    translate([5, 0, 0]) {
        import("profilo.dxf");
    }
}

Ruota il profilo DXF importato attorno all'asse Z. La funzione translate sposta il profilo prima della rotazione.

26 - Surface

26.1 - PNG

surface(file = "immagine.png", center = true, invert = false, convexity = 5);

Crea una superficie 3D basata sui valori di luminosità di un'immagine PNG. I pixel più chiari diventano punti più alti. invert = true inverte la mappa (chiaro diventa basso) 。

26.2 - TXT

File dati.txt:

10 20 30
20 30 40
30 40 50

surface(file = "dati.txt", center = true, convexity = 5);

Crea una superficie basata su una matrice di valori in un file di testo. Ogni numero rappresenta l'altezza in quel punto. Righe e colonne corrispondono agli assi Y e X 。

27 - File STL

27.1 - import

import("modello.stl");

Importa un file STL come oggetto 3D.

27.1 - Modifica File STL

27.1.1 - Crea cubo

cube(20, center=true);
// esporta F5 -> F6 -> F7 -> box.stl

27.1.2 - Modifica STL

I parametri usati in questo esempio seguono la sintassi del Customizer, spiegata in dettaglio nella sezione 28. Dopo aver letto la sezione 28, torna qui per comprendere come i commenti speciali /* [Nome] */ e le annotazioni // [min:max] generano automaticamente i controlli nell'interfaccia del Customizer.

/* [Dimensioni Box] */
scala_X = 40; // [10:100]
scala_Y = 40; // [10:100]
altezza_box = 20; // [5:100]

/* [Foro e Smussatura] */
raggio_smussatura = 2; // [1:5]
diametro_foro = 5;     // [2:15]

/* [Hidden] */
$fn = 50;
altezza_foro = altezza_box + 10;

difference() {
    minkowski() {
        scale([scala_X/40, scala_Y/40, altezza_box/20]) {
            import("box.stl", convexity=5);
        }
        cylinder(r=raggio_smussatura, h=raggio_smussatura, center=true);
    }
    
    cylinder(d=diametro_foro, h=altezza_foro, center=true);
}

Importa un STL, lo scala, lo smussa con minkowski e crea un foro passante. I parametri modificabili dall'utente sono organizzati in schede del Customizer: Dimensioni Box per le scale e l'altezza, Foro e Smussatura per il raggio di smussatura e il diametro del foro, mentre la sezione Hidden contiene variabili non mostrate nell'interfaccia.

28 - Customizer

28.1 - Tipi

// Interruttore Booleano (Casella di spunta)
ha_foro = true;

// Slider base con valori interi
diametro_foro = 8; // [1:1:90]

// Slider con passo decimale
spessore_parete = 1.5; // [0.5:0.1:5.0]

// Menu a discesa numerico
moltiplicatore = 4; // [2, 4, 6, 8]

// Menu a discesa di testo (stringhe)
colore = "red"; // [red, green, blue]
materiale = "PLA"; // [PLA, ABS, PETG]

// Menu con etichette descrittive
risoluzione = 64; // [32:Bassa qualita, 64:Media qualita, 128:Alta qualita]

// Vettori tridimensionali
dimensioni_cubo = [60,60,60];

28.2 - Schede di Navigazione / Tabs

/* [Dimensioni del Cubo] */
dimensioni_cubo = [60,60,60];

/* [Opzioni Foro] */
ha_foro = true;
diametro_foro = 8; // [1:1:90]

/* [Proprietà del Modello] */
colore = "red"; // [red, green, blue]
materiale = "PLA"; // [PLA, ABS, PETG]

28.3 - Variabili Nascoste / Hidden

/* [Hidden] */
version_model = 1.0;

28.2 - Esempio Completo: Cubo Forato

/* [Dimensioni del Cubo] */
dimensioni_cubo = [60,60,60];

/* [Opzioni Foro] */
ha_foro = true;
diametro_foro = 8; // [1:1:90]

/* [Proprietà del Modello] */
colore = "red"; // [red, green, blue]
materiale = "PLA"; // [PLA, ABS, PETG]

/* [Risoluzione e Dettagli] */
risoluzione = 60;

/* [Hidden] */
version_model = 1.0;

/* [Codice Geometrico] */

$fn = risoluzione;

echo(str("materiale : ", materiale));
echo(str("colore : ", colore));

color(colore) {
    difference() {
        cube(size = dimensioni_cubo, center = true);
        
        if (ha_foro) {
            cylinder(h = dimensioni_cubo.z + 0.2, d = diametro_foro, center = true);
        }
    }
}

29 - Installare Librerie (BOSL2)

29.1 - Installazione libreria

Link: https://github.com/BelfrySCAD/BOSL2/

1) Cercare la voce: Releases, cliccare sulla voce della versione attuale
2) Cercare voce: Assets
3) Cliccare su: Source code (zip)
4) Scaricare nella cartella dove si è aperto la finestra avendo cliccato:
-> File -> Show Library Folder ->

Dopo estrazione rinominare la cartella in BOSL2

29.2 - Esempio BOSL2: Cubo Forato

include <BOSL2/std.scad>

/* [Dimensioni del Cubo] */
dimensioni_cubo = [60,60,60];

/* [Opzioni Foro] */
ha_foro = true;
diametro_foro = 8; // [1:1:90]

/* [Proprietà del Modello] */
colore = "red"; // [red, green, blue]
materiale = "PLA"; // [PLA, ABS, PETG]

/* [Risoluzione e Dettagli] */
risoluzione = 60;

/* [Hidden] */
version_model = 1.0;

/* [Codice Geometrico] */

$fn = risoluzione;

echo(str("materiale : ", materiale));
echo(str("colore : ", colore));

color(colore) {
    diff() {
        cuboid(dimensioni_cubo) {
            if (ha_foro) {
                tag("remove") 
                    cyl(d = diametro_foro, l = dimensioni_cubo.z + 0.2, orient = BOTTOM);
            }
        }
    }
}

30 - Conclusione

OpenSCAD è uno strumento potente per la progettazione parametrica di modelli per la stampa 3D . La sua natura basata su codice permette di creare progetti facilmente modificabili e riutilizzabili, adatti sia per uso personale che per la condivisione su piattaforme come Thingiverse 。Con le conoscenze acquisite in questi appunti, è possibile iniziare a progettare oggetti personalizzati e sfruttare appieno le potenzialità della stampa 3D.