Vamos a aplicar todo lo anterior a un caso real: una carcasa para la Heltec WiFi LoRa 32 (V3), una placa muy usada en proyectos LoRa y The Things Network. Tiene pantalla OLED (un display pequeño y fino, sin retroiluminación, donde cada píxel emite su propia luz), conector USB-C, una toma SMA (el conector roscado estándar para antenas de radio) para la antena y a veces un interruptor de alimentación. Además aprovecharemos para hacer dos cosas que distinguen un diseño de aficionado de uno de taller: una biblioteca de cutouts reutilizable y la parametrización del grosor de pared según el material.

El problema del grosor de pared por material

No todos los plásticos de impresión se comportan igual. Una pared de 1.2 mm que aguanta bien en PLA puede quedar frágil en ASA, y los huecos de los conectores necesitan tolerancias distintas según cómo encoja cada material al enfriarse (esa contracción tras la impresión la viste en el módulo 1). En lugar de tener tres archivos distintos, definimos el material como variable y derivamos el grosor de él:

// Material objetivo: "PLA", "PETG" o "ASA"
material = "PETG"; // [PLA, PETG, ASA]

// Grosor de pared recomendado por material
function pared_por_material(m) =
    m == "PLA"  ? 2.0 :
    m == "PETG" ? 2.4 :
    m == "ASA"  ? 2.8 : 2.4;

// Holgura para encajes según contracción del material
function holgura_por_material(m) =
    m == "PLA"  ? 0.20 :
    m == "PETG" ? 0.30 :
    m == "ASA"  ? 0.35 : 0.30;

grosor_pared = pared_por_material(material);
holgura      = holgura_por_material(material);

Aquí usamos funciones de OpenSCAD (devuelven un valor, no geometría) con el operador ternario cond ? a : b encadenado (se lee “si cond, vale a; si no, b”: una elección entre dos valores en una sola línea). Cambiando material = "ASA"; arriba, toda la caja se recalcula con pared más gruesa y más holgura. Esto es diseño paramétrico de verdad.

Material	Pared	Holgura encaje	Notas
PLA	2.0 mm	0.20 mm	Rígido, fácil; mala resistencia a calor
PETG	2.4 mm	0.30 mm	Buen equilibrio, algo flexible
ASA	2.8 mm	0.35 mm	Exterior, resistente a UV; más contracción

Una biblioteca de cutouts reutilizable

La idea clave de este caso práctico es no volver a modelar un hueco de USB-C nunca más. Creamos un archivo lib/cutouts.scad con un módulo por conector, parametrizado con la holgura:

// lib/cutouts.scad
// Huecos de conectores reutilizables.
// Convención: el hueco se genera centrado en el origen,
// extruido en +Y, listo para restar de una pared.

module cut_usbc(holgura = 0.3, profundidad = 6) {
    // USB-C: ~9.0 x 3.2 mm, esquinas redondeadas
    w = 9.0 + holgura;
    h = 3.4 + holgura;
    translate([0, -1, 0])
        hull() {
            for (sx = [-1, 1])
                translate([sx * (w/2 - h/2), 0, 0])
                    rotate([-90, 0, 0])
                        cylinder(h = profundidad, d = h, $fn = 40);
        }
}

module cut_sma(holgura = 0.3, profundidad = 6) {
    // Conector SMA: taladro de 6.5 mm de diámetro
    translate([0, -1, 0])
        rotate([-90, 0, 0])
            cylinder(h = profundidad, d = 6.5 + holgura, $fn = 48);
}

module cut_interruptor(holgura = 0.3, profundidad = 6) {
    // Interruptor deslizante: rectángulo de 13 x 7 mm
    w = 13 + holgura;
    z = 7 + holgura;
    translate([-w/2, -1, -z/2])
        cube([w, profundidad, z]);
}

Fíjate en la convención: cada módulo genera el hueco centrado en el origen y orientado para restarse de una pared frontal (extruido en +Y). Así, colocarlos es solo cuestión de translate y rotate. Esta biblioteca la reutilizaremos tal cual en el siguiente caso práctico del teclado Corne.

Montar la carcasa de la Heltec V3

La placa Heltec V3 mide aproximadamente 50.2 x 25.5 mm. Definimos la caja como un cuerpo redondeado al que restamos el hueco interior y los cutouts:

use <lib/cutouts.scad>

// Dimensiones de la placa
pcb_l = 50.2;
pcb_w = 25.5;

// Caja exterior derivada
caja_l = pcb_l + 2 * grosor_pared + 1.0;
caja_w = pcb_w + 2 * grosor_pared + 1.0;
caja_h = 18;

module placa_redondeada(l, w, h, r) {
    hull()
        for (x = [r, l - r])
            for (y = [r, w - r])
                translate([x, y, 0])
                    cylinder(h = h, r = r, $fn = 40);
}

difference() {
    // cuerpo exterior
    placa_redondeada(caja_l, caja_w, caja_h, 3);

    // vaciado interior
    translate([grosor_pared, grosor_pared, grosor_pared])
        placa_redondeada(
            caja_l - 2 * grosor_pared,
            caja_w - 2 * grosor_pared,
            caja_h, 2);

    // --- cutouts en la cara frontal (y = 0) ---
    // USB-C centrado
    translate([caja_l / 2, grosor_pared, 8])
        cut_usbc(holgura);

    // SMA a un lado
    translate([12, grosor_pared, 11])
        cut_sma(holgura);

    // interruptor al otro lado
    translate([caja_l - 12, grosor_pared, 9])
        cut_interruptor(holgura);
}

El truco está en que los cutouts ya saben su forma; tú solo decides dónde van con un translate. Como su profundidad supera el grosor de pared y arrancan en y = -1, atraviesan limpiamente la pared sin dejar caras coplanares.

Standoffs para el PCB

Para sujetar la placa añadimos cuatro pilares con agujero de tornillo M2 (la métrica de 2 mm de diámetro, habitual en electrónica pequeña):

module standoff(altura, d_ext = 5, d_tornillo = 1.7) {
    difference() {
        cylinder(h = altura, d = d_ext, $fn = 40);
        translate([0, 0, 1])
            cylinder(h = altura, d = d_tornillo, $fn = 30);
    }
}

// (añádelos dentro de la pieza, en las esquinas del PCB)

El diámetro 1.7 mm deja que un tornillo M2 autorrosque en PLA o PETG sin agrietar.

Lo que te llevas de este caso

• El material es un parámetro, no una decisión que rehaces a mano: pared y holgura se derivan de él.
• Los cutouts son una biblioteca: USB-C, SMA e interruptor quedan modelados una vez y se reutilizan.
• La caja es un difference entre dos placas redondeadas con hull, más los huecos.

En el siguiente artículo reaprovecharemos exactamente esta biblioteca de cutouts para un proyecto distinto: el case de un teclado Corne.