Introdución a OpenScad


Para el modelado en 3D,  la famosa aplicación web de AutoDesk  Tinkercad debería ayudarnos ante cualquier diseño inicial  de una manera  más sencilla con el proceso de modelado 3D, tanto es así, que incluso los modeladores experimentados lo hacen  explorando las formas de Tinkercad,  pues curiosamente, una herramienta “simple” como Tinkercad puede utilizarse para crear formas complejas.

Lógicamente detrás del interfaz gráfico de  Tinkercad  ( o de cualquier otro programa de modelado 3D),   está el código que procesa las manipulaciones del diseñador , de modo que a medida que arrastra y suelta formas, los algoritmos complejos están trabajando para calcular cómo aparecerán los gráficos en la pantalla  y generando las formas 3d.

 

OpenSad   en efecto surgen ante el dilema de que  también debería ser posible crear figuras geométricas directamente mediante código, de un  modo  mucho mas eficiente   y conciso   que el  proceso de diseño que cualquier otra herramienta gráfica como por ejemplo Tinkercad.

A diferencia de Tinkercad, OpenSCAD no es una aplicación basada en la web , de  modo que si esta interesado  en la herramienta   tendrá que descargarla  gratuitamente   desde http://www.openscad.org  ( está disponible para Windows, Mac OS X y Linux)   e instalarla en su PC para usarla.

La interfaz OpenSCAD es sencilla  en comparación con Tinkercad ,constando  de sólo tres ventanas, siendo la ventana de la izquierda un editor de texto utilizado para ingresar el código.

panel

Con OpenSCAD pues está diseñando código, pero no se preocupe: escribir código con Open SCAD es muy similar a la sintaxis  HTML  siendo el código para crear objetos  autoexplicativo   ,por ejemplo, el comando del cubo crea cubos, el comando de esfera crea esferas y el comando del cilindro crea cilindros, etc.

Probablemente haya alrededor de 60 comandos en OpenSCAD , algunos de ellos que enunciaremos mas abajo, muchos de los cuales  permitirán manipular la geometría ,  como por ejemplo mover, rotar, escalar y usar operaciones booleanas para combinar objetos, pero no se preocupe porque  para modelar  la mayoría de la piezas solo necesitaran  unos pocos comandos como  son union , difference, translate, cylinder o  cube.

Es facil deducir que en base a esos , es decir mediante secuencias de comandos en el lenguaje de OpenSCAD , se utilizaran para crear modelos en 2D o 3D.

Este script es una lista de formato libre de instrucciones de acción.

 object(); variable = value;
operator() action();
operator()
{ action();
action();
}
operator()
operator()
{ action();
action();
}
operator()
{ operator()
action();
operator()
{ action();
action();
}
}

Como vemos  en el ejemplo  hay  objetos, acciones  y operadores para construir una pieza:

  • Objetos:Los objetos son los bloques de construcción de modelos, creados por primitivas 2D y 3D. Los objetos terminan en un punto y coma ‘;’.
  • Acciones: Instrucciones de acción  que incluyen la creación de objetos usando las primitivas y asignar valores a variables. Las instrucciones de acción también terminan en un punto y coma ‘;’.
  • Operadores :Los operadores o las transformaciones, modifican la ubicación, color y otras propiedades de los objetos. Los operadores usen llaves ‘{}’ cuando su ámbito de aplicación abarca más de una acción. Más de un operador puede usarse para la misma acción o grupo de acciones. Varios operadores se procesan de derecha a izquierda, es decir, el más cercano a la acción del operador se procesa primero. Los operadores no terminan en punto y coma ‘;‘, pero la persona hacen acciones que contienen.

Por ultimo y no menos importante sobre todo para llevar las piezas modeladas al mundo real por ejemplo mediante impresion en 3d, as unidades en OpenSCAD son genéricas  de modo que no hay sistemas de medición en OpenSCAD, es decir , no hay designación para las unidades, y le corresponde al diseñador definir el tamaño del objeto al configurar el archivo antes de la impresión 3D.

 

A modo de resumen  vamos a ver de forma sintetica los entresijos del lenguaje OpenScad;

 

 

RESUMEN DE LAS FUNCIONES MAS IMPORTANTES

Sintaxis de elementos principales

Los usuarios pueden ampliar el lenguaje  definiendo sus propios módulos y funciones. Esto permite agrupar partes de secuencia de comandos de fácil reutilización con diferentes valores. Nombres bien escogidos también ayudan a documentar la secuencia de comandos.

OpenSCAD proporciona: funciones que devuelven valores. módulos que realizan acciones pero no devuelven valores.

OpenSCAD calcula el valor de variables en tiempo de compilación, no tiempo de ejecución. La última asignación variable dentro de un ámbito se aplicará en todo el mundo en ese ámbito. También se aplica a los ámbitos internos, ni los niños, sus. Ver alcance de variables para obtener más detalles. Puede ser útil pensar en ellos como constantes capaz de anular en lugar de variables.

En resumen estas son las cinco construcciones mas usadas ; 

var = value;
Variables en OpenSCAD son creadas por una declaración con un nombre o identificador, asignación a través de una expresión y un punto y coma. El papel de los arreglos de discos, en muchos lenguajes imperativos, se maneja en OpenSCAD mediante vectores.
module name(…) { … } 
Módulos pueden utilizarse para definir objetos o, mediante children(), definir los operadores. Una vez definido, módulos temporalmente se agrega al lenguaje.
function name(…) = … 
Las funciones operan sobre valores para calcular y devolver valores nuevos.
include <….scad>

actúa como si el contenido del archivo incluido fueron escrito en el archivo incluido
use <….scad>

importaciones de módulos y funciones, pero no se ejecuta ningún comando que no sea de esas definiciones

2D

circle (r=radius | d=diameter)

Se crea un círculo en el origen. Todos los parámetros, excepto la r, deben ser nombrados.


Parámetros
radius: radio (debe antecederse la r)
diameter:diametro ( debe antecederse la d)

polygon ([points])

Crea un polígono en base a una  lista de x, y puntos del polígono. : Un vector de vectores elemento 2. (los puntos son indizados desde 0 hasta n-1)

 

polygon ([points], [paths])

Crea una forma echada a un lado múltiples de una lista de coordenadas x, y. Un polígono es el más poderoso objeto 2D. Nada puede crear ese círculo y plazas pueden, y mucho más. Esto incluye formas irregulares con los bordes cóncavos y convexos. Además puede colocar agujeros dentro de esa forma
square ([width, height], center)

Crea un cuadrado o un rectángulo en el primer cuadrante. Cuando el centro es cierto la plaza se centra en el origen. Nombres de argumento son opcionales si en el orden que se muestra a continuación
text (text, size, font, halign, valign, spacing, direction, language, script)

El módulo crea texto como un objeto geométrico 2D, utilizando tipos de letra instalados en el sistema local o como archivo de fuente independiente.

3D

cube (size)

Crea un cubo en el primer octante. Cuando el centro es cierto, el cubo se centra en el origen. Nombres de argumento son opcionales si en el orden que se muestra a continuación.
Al teber solo un valor,el  cubo tiene los lados de esta longitud

cube ([width, depth, height])



Crea un cubo en el primer octante. Cuando el centro es cierto, el cubo se centra en el origen. Nombres de argumento son opcionales si en el orden que se muestra a continuación.
Array de 3 valores [x, y, z] que responde  a las dimensiones x, y y z.

parámetros:
tamaño
solo valor, cubo con los lados de esta longitud
3 valor array [x, y, z], cubo con dimensiones x, y y z.
Centro
falso (predeterminado), 1 º octante (positivo), una de las esquinas en (0,0,0)
cierto, cubo está centrado en (0,0,0)
cylinder (height, BotttonRadios,TopRadius, center)

Crea un cilindro centrado sobre el eje z. Cuando el centro es cierto, también se centra verticalmente a lo largo del eje z.
Nombres de los parámetros son opcionales si en el orden que se muestra Si un parámetro se denomina, deben también llamarse todos los parámetros siguientes.

cylinder (h, r1|d1, r2|d2, center)

Crea un un cono centrado sobre el eje z. Cuando el centro es cierto, también se centra verticalmente a lo largo del eje z. 
Nombres de los parámetros son opcionales si en el orden que se muestra Si un parámetro se denomina, deben también llamarse todos los parámetros siguientes
 Si se utilizan r, d, d1 o d2 deben llamarse.

Parámetros
h : altura del cilindro o de cono
r : radio del cilindro. R1 = r2 = r.
R1 : radio, parte inferior del cono.
R2 : radio superior del cono.
d : diámetro del cilindro. R1 = r2 = 2 d.
D1 : diámetro, parte inferior del cono. R1 = d1/2
D2 : diámetro superior del cono. R2 = d2/2
(Nota: d, d1, d2 requiere 2014.03 o posterior. Debian en la actualidad se sabe que detrás de esto)
Centro
falso (por defecto), z va desde 0 a h
cierto, rangos de z de -h/2 a + h/2

polyhedron (points, triangles, convexity)

Un poliedro es el sólido primitivo 3D más general. Puede utilizarse para crear cualquier figura regular o irregular, incluyendo aquellos con características tanto cóncavos como convexos. Superficies curvas se aproximan por una serie de superficies planas.

Parámetros
puntos
Vector 3d puntos o vértices. Cada punto es a su vez un vector [x, y, z], de sus coordenadas.
Puntos pueden definirse en cualquier orden. N puntos se hace referencia en el orden definido como 0 a N-1.
triángulos (obsoleto en 2014,03, caras de uso versión)
Vector de caras que incluyen colectivamente el sólido. Cada cara es un vector que contiene los índices (basado en 0) de 3 puntos desde el vector de puntos.
caras (introducido en la versión 2014.03)
Vector de caras que incluyen colectivamente el sólido. Cada cara es un vector que contiene los índices (basado en 0) de 3 o más puntos el vector de puntos.
Caras pueden definirse en cualquier orden. Definir bastante caras para incluir completamente el sólido, sin traslapo.
Puntos que describen una sola cara deben estar en el mismo plano.
convexidad
Entero. El parámetro de convexidad especifica el número máximo de caras puede penetrar un rayo que se intersecan el objeto. Este parámetro sólo es necesario para visualizar correctamente el objeto en modo de vista previa OpenCSG. Tiene ningún efecto en la prestación del poliedro. Para problemas de la pantalla, ponerla a 10 debería funcionar bien para la mayoría de los casos.

sphere (radius | d=diameter)

Crea una esfera en el origen del sistema coordinado. El nombre de argumento de r es opcional. Para utilizar d en lugar de r, d debe ser nombrado.

 

 

Parámetros

Radio. Este es el radio de la esfera. La resolución de la esfera se basará en el tamaño de la esfera y el $fa, $fs y $fn variables. Para obtener más información sobre estas variables especiales: 
Diámetro. Esto es el diámetro de la esfera.

(Nota: d sólo está disponible en versiones de 2014.03. Debian en la actualidad se sabe que detrás de esto)

$fa 
Ángulo de fragmento en grados
$fs 
Dimensión en mm del fragmento
$fn 
Resolución

Transformaciones

translate ([x, y, z])

Se traduce (se mueve) en sus elementos secundarios a lo largo del vector especificado. El nombre de argumento es opcional.
rotate ([x, y, z])

Gira su child  ‘a’ grados sobre el eje del sistema coordinado o alrededor de un eje arbitrario. Los nombres de argumento son opcionales si los argumentos se dan en el mismo orden como se especifica.
scale ([x, y, z])

La escala de sus elementos secundarios mediante el vector especificado. El nombre de argumento es opcional.
resize ([x, y, z], auto)

Modifica el tamaño del objeto secundario para que coincida con el dado x,y y z

mirror ([x, y, z])

Refleja el elemento en un plano que pase por el origen 
multmatrix (m)

Multiplica la geometría de todos los elementos secundarios con la matriz de transformación de 4 x 4 dada.
Uso: multmatrix (m = […]) { … }
color («colorname»)

Los nombres de los colores disponibles son los de lista del color SVG la World Wide Web consortium.

color ([r, g, b, a])

Muestra los elementos secundarios mediante el color RGB especificado + valor alfa. Sólo se utiliza para la previsualización de F5 como CGAL y STL (F6) actualmente no admiten color. El valor de alfa por defecto 1.0 (opaco) si no se especifica.

offset (r|delta, chamfer)

Desplazamiento permite mover contornos 2D hacia afuera o hacia adentro por una cantidad dada.
hull()

Muestra el casco convexo de los nodos secundarios.

minkowski()


Muestra la suma de minkowski de nodos secundarios. Se suele utilizar para hace figuras redondeadas en las aristas 


Operaciones booleanas

union()

Crea una Unión de su hijo nodos. Es la suma de todos los hijos (lógica de o).
Se puede utilizar con objetos 2D o 3D, pero no mezclarlas.
difference()

Resta los nodos hijo 2 º (y todos los otros) de la primera ( y no).
Se puede utilizar con objetos 2D o 3D, pero no mezclarlas.
intersection()

Crea la intersección de todos los nodos secundarios. Esto mantiene la porción traslapada (lógica y).
Se conserva sólo la zona que es común o compartido por todos los hijos.
Se puede utilizar con objetos 2D o 3D, pero no mezclarlas.

Modificadores de carácter

*Desactivar
!Mostrar sólo
#Destacar / debug
%Transparente / antecedentes

Matemáticas

abs

Corresponde a la funcion del valor absoluto. Devuelve el valor positivo de un número decimal con signo.
acos

arcoseno, o coseno inverso, expresado en grados.
asin

arco seno, o seno inverso, expresado en grados
atan

arco tangente, o tangente inversa, matemática. Devuelve el valor principal de la arco tangente de x, expresada en grados.
atan2

atan dos argumentos , tomando y como su primer argumento. Devuelve el valor principal de la arco tangente de y / x, expresada en grados

ceil

Función matemática techo .
Devuelve el valor de entero más próximo por redondeo el valor si es necesario.
cos

Función matemática coseno de grados.

exp

Función matemática exp . Devuelve la función exponencial de base e de x, que es el número e elevado a la potencia x.
floor

Función matemática flooro . Floor(x) = el entero más grande no es mayor que x
len

Función matemática longitud . Devuelve la longitud de una matriz, un vector o un parámetro de cadena.

let

Asignación secuencial de variables dentro de una expresión. La siguiente expresión se evalúa en el contexto de las tareas que y puede utilizar las variables. Esto es principalmente útil para realizar complicadas expresiones más legible mediante la asignación de resultados provisionales a las variables.
ln

Función matemática logaritmo natural.
log

Función matemática del logaritmo en base 10.

max

Devuelve el máximo de los parámetros. Si se da un único vector como parámetro, devuelve el máximo elemento de ese vecto
min

Devuelve el mínimo de los parámetros. Si se da un único vector como parámetro, devuelve el mínimo elemento de ese vector.

pow

Función matemática potencia
rands

Generador de números aleatorios. Genera un vector constante de pseudo números aleatorios, al igual que una matriz. Los números son dobles no enteros. Cuando se genera un único número, se llama todavía con variable [0]
round


El operador devuelve la parte entera más o menos, respectivamente, si la entrada numérica es positivo o negativo
sign


Función matemática signum . Devuelve un valor de unidad que extrae la señal de un valor
sin

Función matemática seno
sqrt

Función matemática de raíz cuadrada .
tan

Función de la tangente de matemática.

Funciones

chr

Convertir a números en una cadena que contiene caracteres con el código correspondiente. OpenSCAD utiliza Unicode, por lo que el número se interpreta como punto de código Unicode. Números fuera del intervalo de punto de código válido producirá una cadena vacía.
concat

Devuelven un vector que contiene los argumentos.
Donde argumento es un vector de los elementos del vector se agregan individualmente al vector resultado. Cadenas son diferentes de vectores en este caso
cross


Calcula el producto cruzado de dos vectores en el espacio 3D. El resultado es un vector que es perpendicular a ambos vectores de entrada.
Utilizando parámetros de entrada no válidos (por ejemplo vectores con una longitud diferente de 3 o de otro tipo) producirá un resultado indefinido.
lookup

Buscar valor en tabla e interpolar linealmente si no hay ninguna coincidencia exacta. El primer argumento es el valor a buscar. La segunda es la tabla de búsqueda–un vector de pares de clave y valor.
norm

Devuelve la norma euclideana de un vector. Tenga en cuenta que esto devuelve la longitud numérica real mientras que len devuelve el número de elementos en el vector o matriz.

parent_module (idx)

$parent_modules contiene el número de módulos en la pila de ejecución. parent_module(i) devuelve el nombre del módulo niveles por encima del módulo actual en la pila de ejecución. La pila es independiente de donde se definen los módulos. Es donde ellos son instancias que cuenta. Esto puede usarse para construir por ejemplo, las listas de materiale
search

Buscar valor en tabla e interpolar linealmente si no hay ninguna coincidencia exacta. El primer argumento es el valor a buscar. La segunda es la tabla de búsqueda–un vector de pares de clave y valor.
str

Convertir todos los argumentos a las cadenas y concatenar.
version

devuelve el número de versión de OpenSCAD.

version_num

devuelve el número de versión de OpenSCAD

Otros

children ([idx])


Los objetos se indizan mediante enteros de 0 a $children-1. OpenSCAD establece $children el número total de objetos en el ámbito de aplicación. Objetos agrupados en un ámbito sub se tratan como un hijoo.
echo (…)

Esta función imprime el contenido de la ventana de compilación (también conocido como consola). Útil para depurar código.
Valores numéricos se redondean a 5 dígitos significativos.
La consola OpenSCAD soporta un subconjunto de lenguaje de marcado HTML
for (i = [start:end]) { … }

Bucle para evaluar cada valor en un rango, aplicándola a la acción siguiente.


Parámetros
start – valor inicial
end – parada cuando el siguiente valor sea final
for (i = [start:step:end]) { … }

Bucle para evaluar cada valor en un rango , aplicándola a la acción siguiente.


Parámetros
start – valor inicial
step o paso – cantidad para aumentar el valor, opcional, por defecto = 1
end – parada cuando el siguiente valor sea final
for (i = […, …, …]) { … }

Bucle evaluando cada valor en un  vector, aplicándola a la acción siguiente.
if (…) { … }

Estructura condicional realizando una prueba para determinar si las acciones en un ámbito secundario deben realizarse o no.

import («….stl»)

Importa un archivo para su uso en el modelo actual de OpenSCAD. OpenSCAD actualmente soporta importación de DXF, apagado y ficheros STL (ASCII y binario). La extensión de archivo se utiliza para determinar el tipo.
intersection_for (i = [start:end]) { … }

Iterar sobre los valores en un rango y crear la intersección de objetos creados por cada pasada.
Además de crear instancias independientes para cada paso, el estándar for() también agrupa todas estas instancias de creación de una Unión implícita.

Parámetros
start – valor inicial
end – parada cuando el siguiente valor sea final

intersection_for (i = [start:step:end]) { … }


Iterar sobre los valores en un rango y crear la intersección de objetos creados por cada pasada.
Además de crear instancias independientes para cada paso, el estándar for() también agrupa todas estas instancias de creación de una Unión implícita.

Parámetros
start – valor inicial
step o paso – cantidad para aumentar el valor, opcional, por defecto = 1
end – parada cuando el siguiente valor sea final
intersection_for (i = […, …, …]) { … }


Iterar sobre los valores en un  vector y crear la intersección de objetos creados por cada pasada.
Además de crear instancias independientes para cada paso, el estándar for() también agrupa todas estas instancias de creación de una Unión implícita.
linear_extrude (height, center, convexity, twist, slices)



Es una operación de modelado que toma un polígono 2D como entrada y extiende en la tercera dimensión de modo que se crea así una forma 3D. Tenga en cuenta que la protuberancia se realiza siempre del plano XY a la altura indican a lo largo del eje Z ; así que si se gira o aplicar otras transformaciones antes de extrusión, la extrusión se aplica a la proyección del polígono 2D en el plano XY.


Parámetros

height -altura, 
center -centro, 
convexity-convexidad, 
twits-torcedura, 
slices-rodajas
projection (cut)


Utilizando la función, puede crear dibujos en 2d de modelos en 3d y exportarlos al formato dxf. Funciona proyectando un modelo 3D (x, y) plano, con z en 0. If, sólo puntos con z = 0 se considerará (cortando efectivamente el objeto), con (el valor predeterminado), puntos por encima y por debajo del plano se considerarán así (creando una proyección adecuada).
projection()cut=truecut=false
render (convexity)

Las fuerzas de la generación de una malla incluso en modo de vista previa. Útil para ser demasiado lentos para seguir las operaciones booleanas.

rotate_extrude (convexity)

Gira alrededor del eje z para formar un sólido que tiene simetría de rotación una figura en 2D. Una forma de pensar de esta operación es imaginar un torno de alfarero colocada en el plano X-Y con su eje de rotación hacia arriba hacia + Z. Luego colocando el objeto por el hecho de ser en esta virtual de alfarero (posiblemente extendido hacia abajo por debajo del plano X-Y a -Z, tomar la sección de este objeto en el plano X-Z pero mantener solamente el derecho de la mitad (X > = 0). Es la forma 2D que necesitan ser alimentados a rotate_extrude() como el niño con el fin de generar este sólido.
Desde una forma 2D se procesa por OpenSCAD en el plano X-Y, una manera alternativa de pensar de esta operación es la siguiente: hace girar una figura en 2D alrededor del eje y para formar un sólido. El sólido resultante se coloca de modo que su eje de rotación se encuentra a lo largo del eje z.
No puede utilizarse para producir una hélice o rosca.
La forma 2D necesita mentir completamente en el derecho de cualquiera de los dos (recomendado) o el lado izquierdo del eje y. Más precisamente hablando, cada vértice de la forma debe tener ya sea x > = 0 o x < = 0. Si la forma cruza el eje X una advertencia aparecerá en la ventana de consola y se ignorará el rotate_extrude(). Para OpenSCAD versiones anteriores a 2016.xxxx, si la forma es en el eje negativo las caras será al revés, que puede causar efectos no deseados
surface (file, center, invert, convexity)


Lee mapa información de archivos de texto o imagen.

Parámetros
file : La ruta del archivo que contiene los datos del mapa.
center:Esto determina la posición del objeto generado. Si es cierto objeto se centra en x y el eje y. De lo contrario, el objeto se coloca en el cuadrante positivo. Por defecto false.
invert: Invierte como los valores de color de imágenes importadas se traducen en valores de altura. Esto no tiene ningún efecto al importar archivos de datos de texto. Por defecto false.
convexity. El parámetro de convexidad especifica el número máximo de partes delanteras (lados traseros) podría penetrar un rayo que se intersecan el objeto. Este parámetro sólo es necesario para visualizar correctamente el objeto en modo de vista previa OpenCSG y no tiene ningún efecto en la prestación final.

Compresiones de listas

Generar[ for (i = range|list) i ]
es decir

[para (i = rango | lista) i]
Condiciones[ for (i = …) if (condition(i)) i ]

es decir 
[para (i =…) si (conditcon(i)) i]
Asignaciones[ for (i = …) let (assignments) a ]

es decir

[para (i =…) que (asignaciones) un]

Variables especiales

$childrenNúmero de hijos de módulo
$faÁngulo mínimo
$fsTamaño mínimo
$fnNúmero de fragmentos
$tPaso de la animación
$vprRotación de la vista
$vptTraducción de ventanilla
$vpdDistancia de la cámara de ventanilla

Mas información en  https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/

htt

Introducción al modelado 3d con OpenSCAD para electrónicos


Para el modelado 3D, Tinkercad debería ayudarnos ante cualquier diseño inicial de una manera  más sencilla con el proceso de modelado 3D, tanto es así, que incluso los modeladores experimentados lo hacen  explorando las formas de Tinkercad,  pues curiosamente, una herramienta «simple» como Tinkercad puede conducir a formas complejas.

Lógicamente detrás de Tinkercad y de cualquier otro programa de modelado 3D está el código, de modo que a medida que arrastra y suelta formas, los algoritmos complejos están trabajando para calcular cómo aparecerán los gráficos en la pantalla, asi que  también debería ser posible crear figuras geométricas directamente mediante código.

Para aquellos que tienen curiosidad sobre el código, OpenSCAD es una herramienta gratuita de software para explorar el modelado 3d desde esa perspectiva,  resultando  mucho mas eficiente   y concisa   en el  proceso de diseño que cualquier otra herramienta gráfica como por ejemplo Tinkercad..

A diferencia de Tinkercad, OpenSCAD no es una aplicación basada en la web de  modo que si esta interesado  en la herramienta   tendrá que descargarla ( OpenSCAD se puede descargar gartis en http://www.openscad.org y está disponible para Windows, Mac OS X y Linux)   e instalarla en su PC para usarla.

La interfaz OpenSCAD es sencilla  en comparación con Tinkercad ,constando  de sólo tres ventanas, siendo la ventana de la izquierda un editor de texto utilizado para ingresar el código.

 

panel

Con OpenSCAD está diseñando código,pero no se preocupe: escribir código con Open SCAD es similar al uso de HTML en una página web, siendo el código para crear objetos  autoexplicativo  (por ejemplo, el comando del cubo crea cubos, el comando de esfera crea esferas y el comando del cilindro crea cilindros, etc).

Probablemente haya alrededor de 60 comandos en OpenSCAD, muchos de los cuales  permitirán manipular la geometría ,  como por ejemplo mover, rotar, escalar y usar operaciones booleanas para combinar objetos, pero no se preocupe porque  para modelar  la mayoría de la piezas solo necesitaran  unos pocos comandos como  son union , difference, translate, cylinder o  cube.

 

Las secuencias de comandos en el lenguaje de OpenSCAD se utilizan para crear modelos en 2D o 3D.

Este script es una lista de formato libre de instrucciones de acción.

 object();
 variable = value;
 operator()   action();
 operator() { action();    action(); }
 operator()   operator() { action(); action(); }
 operator() { operator()   action();
              operator() { action(); action(); } }

 

Como vemos  hay objetos,acciones  y operadores para construir un pieza:

  • Objetos:Los objetos son los bloques de construcción de modelos, creados por primitivas 2D y 3D. Los objetos terminan en un punto y coma ‘;’.
  • Acciones: Instrucciones de acción  que incluyen la creación de objetos usando las primitivas y asignar valores a variables. Las instrucciones de acción también terminan en un punto y coma ‘;’.
  • Operadores :Los operadores o las transformaciones, modifican la ubicación, color y otras propiedades de los objetos. Los operadores usen llaves ‘{}’ cuando su ámbito de aplicación abarca más de una acción. Más de un operador puede usarse para la misma acción o grupo de acciones. Varios operadores se procesan de derecha a izquierda, es decir, el más cercano a la acción del operador se procesa primero. Los operadores no terminan en punto y coma ‘;‘, pero la persona hacen acciones que contienen.

 

 

Las unidades en OpenSCAD son genéricas  de modo que no hay sistemas de medición en OpenSCAD, es decir , no hay designación para las unidades, y le corresponde al diseñador definir el tamaño del objeto al configurar el archivo antes de la impresión 3D.

CLINDRO (Cylinder)


Crea un cilindro o un cono centrado sobre el eje z. Cuando el centro es cierto, también se centra verticalmente a lo largo del eje z.

Nombres de los parámetros son opcionales si en el orden que se muestra a continuación. Si un parámetro se denomina, deben también llamarse todos los parámetros siguientes.

Nota: Si se utilizan r, d, d1 o d2 debe llamarse.

cylinder(h = height, r1 = BottomRadius, r2 = TopRadius, center = true/false);
Parámetros
h : altura del cilindro o de cono
r : radio del cilindro. R1 = r2 = r.
R1 : radio, parte inferior del cono.
R2 : radio superior del cono.
d : diámetro del cilindro. R1 = r2 = 2 d.
D1 : diámetro, parte inferior del cono. R1 = d1/2
D2 : diámetro superior del cono. R2 = d2/2

(Nota: d, d1, d2 requiere 2014.03 o posterior. Debian en la actualidad se sabe que detrás de esto)
Centro

falso (por defecto), z va desde 0 a h
cierto, rangos de z de -h/2 a + h/2
$fa : ángulo mínimo (en grados) de cada fragmento.
$fs : longitud circunferencial mínima de cada fragmento.
$fn : fija el número de fragmentos en 360 grados. Valores de 3 o más reemplazar $fa y $fs

$fa, $fs y $fn deben ser nombrados. 
defaults: cylinder();  yields: cylinder($fn = 0, $fa = 12, $fs = 2, h = 1, r1 = 1, r2 = 1, center = false);

OpenSCAD Cone 15x10x20.jpg

equivalent scripts
 cylinder(h=15, r1=9.5, r2=19.5, center=false);
 cylinder(  15,    9.5,    19.5, false);
 cylinder(  15,    9.5,    19.5);
 cylinder(  15,    9.5, d2=39  );
 cylinder(  15, d1=19,  d2=39  );
 cylinder(  15, d1=19,  r2=19.5);

OpenSCAD Cone 15x10x0.jpg

equivalent scripts
 cylinder(h=15, r1=10, r2=0, center=true);
 cylinder(  15,    10,    0,        true);
 cylinder(h=15, d1=20, d2=0, center=true);
equivalent scripts
 cylinder(h=20, r=10, center=true);
 cylinder(  20,   10, 10,true);
 cylinder(  20, d=20, center=true);
 cylinder(  20,r1=10, d2=20, center=true);
 cylinder(  20,r1=10, d2=2*10, center=true);

 

CUBO (Cube)


Crea un cubo en el primer octante. Cuando el centro es cierto, el cubo se centra en el origen. Nombres de argumento son opcionales si en el orden que se muestra a continuación.

cube(size = [x,y,z], center = true/false);
cube(size =  x ,     center = true/false);
parámetros:
tamaño

solo valor, cubo con los lados de esta longitud
3 valor array [x, y, z], cubo con dimensiones x, y y z.
Centro

falso (predeterminado), 1 º octante (positivo), una de las esquinas en (0,0,0)
cierto, cubo está centrado en (0,0,0)
default values:  cube();   yields:  cube(size = [1, 1, 1], center = false);
ejemplos:

OpenSCAD example Cube.jpg

equivalent scripts for this example
 cube(size = 18);
 cube(18);
 cube([18,18,18]);
 .
 cube(18,false);
 cube([18,18,18],false);
 cube([18,18,18],center=false);
 cube(size = [18,18,18], center = false);
 cube(center = false,size = [18,18,18] );

OpenSCAD example Box.jpg

equivalent scripts for this example
 cube([18,28,8],true);
 box=[18,28,8];cube(box,true);

 

 

ROTATE

Gira su objeto ‘a’ grados sobre el eje del sistema coordinado o alrededor de un eje arbitrario. Los nombres de argumento son opcionales si los argumentos se dan en el mismo orden como se especifica.

//Usage:
rotate(a = deg_a, v = [x, y, z]) { ... }  
// or
rotate(deg_a, [x, y, z]) { ... }
rotate(a = [deg_x, deg_y, deg_z]) { ... }
rotate([deg_x, deg_y, deg_z]) { ... }

El argumento ‘a’ (deg_a) puede ser una matriz, tal como se expresa en el uso de más arriba; Cuando deg_a es una matriz, se omite el argumento de ‘v’. Donde ‘a’ especifica múltiples ejes después de la rotación se aplica en el siguiente orden: x, y, z. que significa el código:

rotate(a=[ax,ay,az]) {...}

es equivalente a:

rotate(a=[0,0,az]) rotate(a=[0,ay,0]) rotate(a=[ax,0,0]) {...}

El argumento opcional de ‘v’ es un vector y le permite establecer un eje arbitrario que será girado al objeto.
Por ejemplo, para voltear un objeto boca abajo, se puede girar el objeto 180 grados alrededor del eje ‘y’.

rotate(a=[0,180,0]) { ... }

Con frecuencia esto se simplifica a

rotate([0,180,0]) { ... }

Cuando se especifica un solo eje el argumento de ‘v’ permite especificar cuyo eje es la base para la rotación. Por ejemplo, el equivalente a lo anterior, para girar a la vuelta y

rotate(a=180, v=[0,1,0]) { ... }

Cuando se especifica un solo eje, ‘v’ es un vector de definición de un eje arbitrario de rotación; Esto es diferente del eje múltiple anterior. Por ejemplo, rotar el objeto 45 grados alrededor del eje definido por el vector [1,1,0],

rotate(a=45, v=[1,1,0]) { ... }

 

 

TRANSLATE

Se  mueve sus elementos secundarios a lo largo del vector especificado. El nombre de argumento es opcional.

Example:
translate(v = [x, y, z]) { ... }
cube(2,center = true); 
translate([5,0,0]) 
   sphere(1,center = true);

image of result of the translate() transformation in OpenSCAD

image of result of rotate() transformation in OpenSCAD

 

 

MINKOWSKY

Muestra la suma de minkowski de los nodos secundarios.

Supongamos que tiene una caja plana y quiere un borde redondeado. Hay muchas formas de hacerlo, pero minkowski es muy elegante.

Por ejemplo toma un cubo  y un cilindro:

 $fn=50;
 cube([10,10,1]);
 cylinder(r=2,h=1);

Luego, haga una suma de minkowski de ellos (tenga en cuenta que las dimensiones exteriores de la caja ahora son 10 + 2 + 2 = 14 unidades por 14 unidades por 2 unidades de altura a medida que se suman las alturas de los objetos):

$fn=50;
minkowski()
{
  cube([10,10,1]);
  cylinder(r=2,h=1);
}

Note que el origen del segundo objeto se usa para la suma. Si el segundo objeto no está centrado, entonces la adición será asimétrica. Las siguientes sumas de Minkowski son diferentes: la primera expande el cubo original en 0.5 unidades en todas las direcciones, tanto positivas como negativas. El segundo lo expande en +1 en cada dirección positiva, pero no se expande en las direcciones negativas.

minkowski() {
    cube([10, 10, 1]);
    cube(1, center=true);
}
minkowski() {
    cube([10, 10, 1]);
    cube(1);
}

 

 

mikonsji.png

En  nuestro  diseño final que veremos  para la caja ATX  nos sirve para   redondear los bordes de la caja  :

minkowski(){
translate([0,0,0]) cube([151,85,29]);
cylinder(r=2);

Observar que una caja ATX es de 151 x 85

 

TRANSFORMACIONES

La transformación afectan a  los nodos secundarios y como su nombre indica transforma de diversas maneras las figuras como moviéndolas , rotándolas   o escaléndolas . Las transformaciones en cascada se utilizan para aplicar una gran variedad de transformaciones a un a figura 

En cascada se logra mediante declaraciones de anidación,

Un ejemplo :

rotate([45,45,45])
  translate([10,20,30])
    cube(10);

Las transformaciones pueden aplicarse a un grupo de nodos secundarios mediante el uso de ‘ {‘ y ‘}’ para incluir por ejemplo el subárbol

translate([0,0,-5])
{
    cube(10);
    cylinder(r=5,h=10);
}

Un  aspecto a tener muy en cuenta es  que las transformaciones se escriben antes el objeto que afectan.

 

 

 

Primer ejemplo

 

Como  habrá  podido deducir , construir una pieza en  OpenSCAD es un proceso mucho más eficiente cuando se  usa código.

Por ejemplo,  el uso de Tinkercad para crear una caja y su tapa toma más de diez operaciones que consisten en dejar caer y arrastrar objetos, alinearlos y agruparlos para crear las formas finales, de modo que  este proceso podría tardar mucho tiempo según el manejo que se tenga de la herramienta.

Con OpenSCAD, puede crear la misma pieza en menos de diez minutos simplemente usando el siguiente código:

difference () {
cube ([4,3,2], center=true);
translate ([0,0,1])
cube ([3.5,2.5,2], center=true);
}

union () {
translate ([0,0,2])
cube ([4,3,.4], center=true);
translate ([0,0,1.8])
cube ([3.49,2.49,.4], center=true);

translate ([0,0,2.2])
scale ([.1,.1,.1])
sphere (r=5, center=true);

translate ([0,0,2.7])
scale ([.07,.07,.07])
sphere (r=5, center=true);
}

Explicamos a continuacion el código:

La primera sección del código se usa para crear una  caja hueca .

El  comando (cube [4,3,2], center = true); crea el cuadro inicial.

El  comando center= true  se usa para asegurar que la caja esté perfectamente centrada en 3D

La siguiente serie de comandos, translate ([0,0,1]) cube ([3.5,2.5,2], center = true) ;, se usa para crear un segundo cuadro más pequeño.

Esta segunda caja, más pequeña, se mueve hacia arriba en 1 unidad en la dirección Z usando el comando translate y se usará en la operación boleana para crear la caja hueca  gracias al comando difference  que  se usa para restar el cuadro más pequeño (3.5×2.5×2)  para el cuadro grande (4x3x2)

Como vemos cualquier comando de forma como cubo, esfera y cilindro que se encuentre dentro de los corchetes que preceden al comando de diferencia se usará en la operación booleana  dando resultado que el primer objeto enumerado en los corchetes tendrá la forma de base, y los objetos anteriores enumerados serán «objetos de corte» y restarán la geometría de la base.

cajas.png

Para la tapa de  la caja, simplemente usaremos el comando unión para   formar una pieza compuesta por dos cubos superpuestos  ,uno de 4x3x.4  y  otro algo  mas pequeño de 3.49×2.49x.4

tapas.png

Los últimos dos conjuntos de comandos crean el mango esférico para la parte superior de la tapa

translate ([0,0,2.2])
scale ([.1,.1,.1])
sphere (r=5, center=true);

translate ([0,0,2.7])
scale ([.07,.07,.07])
sphere (r=5, center=true);

 

Finalmente, el comando de unión se usa para combinar todos los elementos de tapa juntos.

 

caja

 

 

Ejemplo fuente ATX

Para mostrar lo util que es el prototipado  con esta herramienta, vamos   a ver como se puede hacer un tapa a una fuente de ordenador ATX de ordenador  de modo que queden accesibles las tensiones principales de la fuente(+12,-12 y +5V)   y además podamos controlarlas con un conmutador y un instrumento de panel.

El prototipo final es el que mostramos a continuación:

atx2.png

 

 

Podemos ver  la tapa como dos bloques , donde uno sera la caja  y el otro  todos los orificios que se practiquen sobre el mismo

Bloque  inicial

La primera sección del código se usa para crear una  caja hueca  y los agujeros de los laterales.

El  comando translate([0,0,0]) cube([151,85,29]); crea el cuadro inicial  de medidas algo superiores al frontal de una caja ATX dado que debe colocarse esta deno.

La siguiente serie de comandos, trtranslate([0,0,2]) cube([151,85,28]);  se usa para crear un segundo cuadro más pequeño  .

Esta segunda caja, más pequeña, se mueve hacia arriba en 2 unidades en la dirección Z usando el comando translate y se usará en la operación boleana para crear la caja hueca  gracias al comando difference  que  se usa para restar el cuadro más grande al cuadro pequeño

En  el  diseño   para la caja ATX  nos sirve la función minkowski   para   redondear los bordes de la caja  :

minkowski(){
translate([0,0,0]) cube([151,85,29]);
cylinder(r=2);

Observar que una caja ATX es de 151 x 85 x29.

En este bloque además se practican los agujeros  de refrigeracion en la cara inferior por medio de la creación de cilindros de radio 5

//agujeros de refrigeracion
translate([40,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([60,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([75,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([90,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([110,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);

Asimismo, se crean 4 orificios para los 4 tornillos que  serviran para sujetar esta pieza a la caja ATX  :

// 4 agujeros para sujetarlos a la caja ATX
translate([15.5,-2,25]) rotate([-90,0,0]) cylinder(h=3,r1=3.5,r2=1.5);
translate([135.5,-2,25]) rotate([-90,0,0]) cylinder(h=3,r1=3.5,r2=1.5);

translate([-2,80,25]) rotate([0,90,0]) cylinder(h=3,r1=3.5,r2=1.5);
translate([154,80,25]) rotate([0,-90,0]) cylinder(h=3,r1=3.5,r2=1.5);

 

Además, en este bloque se han añadido dos patas  compuestas por dos cubos que se fijaran a la cara inferior

//2 pies de apoyo
translate([10,86,0]) rotate([.5,0,0]) cube([10,3,30]);
translate([131,86,0]) rotate([.5,0,0]) cube([10,3,30]);

 

Bloque de vaciados

Se ha visto interesante reforzar los 5 bornas  por medio de 5 cilindros interiores  que ayudan a  dar más consistencia  a las bornas en su operacion  normal ,las cuales estan   formados simplemente por cilindros  de poca altura:

//refuerzo conectores
translate([18,70,0]) cylinder(h=5,r=6);
translate([38,70,0]) cylinder(h=5,r=6);
translate([58,70,0]) cylinder(h=5,r=6);
translate([151-18,70,0]) cylinder(h=5,r=6);
translate([151-38,70,0]) cylinder(h=5,r=6);

Asimismo  se han añadido refuerzos en el interior para mejorar la estabilidad mecánica  formados por cubos   y que recorren toda la caja :

//Costillas de refuerzo  para la caja
translate([0,0,0]) cube([3,3,20]);
translate([0,82,0]) cube([3,3,20]);
translate([148,0,0]) cube([3,3,20]);
translate([148,82,0]) cube([3,3,20]);
translate([47,0,0]) cube([3,3,20]);
translate([47,82,0]) cube([3,3,20]);
translate([77,0,0]) cube([3,3,20]);
translate([100,82,0]) cube([3,3,20]);
translate([0,40,0]) cube([3,3,20]);
translate([148,50,0]) cube([3,3,20]);
translate([47,40,0]) cube([3,45,4]);
translate([100,50,0]) cube([3,35,4]);
translate([0,40,0]) cube([80,3,4]);
translate([77,0,0]) cube([3,50,4]);
translate([77,50,0]) cube([151-77,3,4]);
}

También es interesante destacar la abertura para el interruptor  de encendido  y el display led  formado por dos  simples cubos , así como tambien  los agujeros para los conectores formados por 5 cilindros:

//Abertura para el display
translate([32,12,0]) cube([45.3,25.7,10]);

//Abertura para el interruptor
translate([15,15,0]) cube([11.7,19.6,10]);

//Agujeros para los conectores
translate([18,70,0]) cylinder(h=9,r=5);
translate([38,70,0]) cylinder(h=9,r=5);
translate([58,70,0]) cylinder(h=9,r=5);
translate([151-18,70,0]) cylinder(h=9,r=5);
translate([151-38,70,0]) cylinder(h=9,r=5);

 

Por ultimo, para mejorar la refrigeración   se ha optado por poner rejillas de ventilación en el frontal formadas cada una por 2 cilindros huecos y un cubo

Como novedad   se realiza  de forma re-cursiva mediante el empleo de un bucle for

//Rejilla de ventilacion
for ( i = [85 : 8 : 145] )
{
translate([i,10,0]) cylinder(h=9,r=2);
translate([i,45,0]) cylinder(h=9,r=2);
translate([i-2,10,0]) cube([4,35,4]);
}

 

Finalmente, si lo unimos todo, tenemos el siguiente código para general la pieza entera:

 

// …………………………
// Panel para fuente ATX
// CRN
// 17/01/2018
// GNU GPL v3
// …………………………

 

module box(){
difference(){
union(){
minkowski(){
translate([0,0,0]) cube([151,85,29]);
cylinder(r=2);
}
//2 pies de apoyo
translate([10,86,0]) rotate([.5,0,0]) cube([10,3,30]);
translate([131,86,0]) rotate([.5,0,0]) cube([10,3,30]);
}
//vaciado de la caja
translate([0,0,2]) cube([151,85,28]);

//agujeros de refrigeracion
translate([40,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([60,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([75,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([90,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);
translate([110,80,12]) rotate([-90,0,0]) cylinder(h=9,r=5);

// 4 agujeros para sujetarlos a la caja ATX
translate([15.5,-2,25]) rotate([-90,0,0]) cylinder(h=3,r1=3.5,r2=1.5);
translate([135.5,-2,25]) rotate([-90,0,0]) cylinder(h=3,r1=3.5,r2=1.5);

translate([-2,80,25]) rotate([0,90,0]) cylinder(h=3,r1=3.5,r2=1.5);
translate([154,80,25]) rotate([0,-90,0]) cylinder(h=3,r1=3.5,r2=1.5);

}
}

 

 

 

 

difference(){
union(){
box();

//refuerzo conectores
translate([18,70,0]) cylinder(h=5,r=6);
translate([38,70,0]) cylinder(h=5,r=6);
translate([58,70,0]) cylinder(h=5,r=6);
translate([151-18,70,0]) cylinder(h=5,r=6);
translate([151-38,70,0]) cylinder(h=5,r=6);

//Costillas de refuerzo  para la caja
translate([0,0,0]) cube([3,3,20]);
translate([0,82,0]) cube([3,3,20]);
translate([148,0,0]) cube([3,3,20]);
translate([148,82,0]) cube([3,3,20]);
translate([47,0,0]) cube([3,3,20]);
translate([47,82,0]) cube([3,3,20]);
translate([77,0,0]) cube([3,3,20]);
translate([100,82,0]) cube([3,3,20]);
translate([0,40,0]) cube([3,3,20]);
translate([148,50,0]) cube([3,3,20]);
translate([47,40,0]) cube([3,45,4]);
translate([100,50,0]) cube([3,35,4]);
translate([0,40,0]) cube([80,3,4]);
translate([77,0,0]) cube([3,50,4]);
translate([77,50,0]) cube([151-77,3,4]);
}
//Abertura para el display
translate([32,12,0]) cube([45.3,25.7,10]);

 

//Aabertura para el interruptor
translate([15,15,0]) cube([11.7,19.6,10]);

 

//Agujeros para los conectores
translate([18,70,0]) cylinder(h=9,r=5);
translate([38,70,0]) cylinder(h=9,r=5);
translate([58,70,0]) cylinder(h=9,r=5);
translate([151-18,70,0]) cylinder(h=9,r=5);
translate([151-38,70,0]) cylinder(h=9,r=5);

//Rejilla de ventilacion
for ( i = [85 : 8 : 145] )
{
translate([i,10,0]) cylinder(h=9,r=2);
translate([i,45,0]) cylinder(h=9,r=2);
translate([i-2,10,0]) cube([4,35,4]);
}
}