En el caso anterior hicimos una carcasa para una placa rectangular. Ahora cambiamos de registro: vamos a diseñar un case para un teclado Corne, el split ergonómico de 42 teclas (3x6 columnas más 3 teclas de pulgar por mitad) que es uno de los proyectos recurrentes del curso; lo montas en el módulo 4 y lo programas en el módulo 5. El reto aquí no es meter un PCB en una caja, sino sujetar interruptores mecánicos (los switches de tecla, que estudias a fondo en el módulo 5) en una placa con sus huecos exactos y montar una carcasa high-profile, es decir, de perfil alto, una pared que sube por encima de las teclas y rodea los switches. Reutilizaremos la biblioteca de cutouts del artículo 2.6. Si alguno de estos términos te suena nuevo, avanza sin problema: aquí solo necesitas su geometría.

Recuerda lo que vimos en el artículo de licencias: el Corne original se publica bajo CC-BY-4.0 (hardware) y MIT (firmware), así que puedes venderlo siempre que atribuyas el diseño a foostan. Aun así, verifica la licencia del fork concreto que uses, porque puede cambiar.

La placa de switches (switch plate)

Un interruptor mecánico estándar (Cherry MX y compatibles, el formato de switch de tecla más extendido) encaja en un hueco cuadrado de 14 x 14 mm. La placa que los sujeta suele tener 1.5 mm de grosor para que las pestañas del switch claven correctamente. El primer paso es modelar un hueco de switch reutilizable:

grosor_placa = 1.5;
hueco_switch = 14.0;   // 14 x 14 mm, estándar MX
paso_tecla   = 19.05;  // espaciado entre centros (0.75")

module hueco_switch(grosor = 1.5) {
    translate([-hueco_switch/2, -hueco_switch/2, -1])
        cube([hueco_switch, hueco_switch, grosor + 2]);
}

El paso de 19.05 mm (0.75 pulgadas) es el estándar de teclado y lo usaremos para colocar las teclas en rejilla. Ese número aparentemente raro no es casualidad: son exactamente tres cuartos de pulgada, la separación heredada de las máquinas de escribir que el teclado nunca llegó a abandonar.

Colocar la matriz con stagger por columnas

El Corne no tiene las columnas alineadas: cada columna está desplazada verticalmente para adaptarse a la longitud de los dedos (column stagger). Definimos ese desplazamiento en una lista y generamos la matriz con bucles:

// Desplazamiento vertical (stagger) por columna, en mm.
// Índice = nº de columna; el meñique y el índice
// quedan más bajos que el corazón.
stagger = [0, 3, 11, 8, 4, 4];

module placa_switches() {
    difference() {
        // base de la placa: 6 columnas x 3 filas + margen
        ancho = 6 * paso_tecla + 8;
        alto  = 3 * paso_tecla + 14;
        translate([-4, -7, 0])
            cube([ancho, alto, grosor_placa]);

        // huecos de las 18 teclas principales
        for (col = [0 : 5])
            for (fila = [0 : 2])
                translate([
                    col * paso_tecla,
                    fila * paso_tecla + stagger[col],
                    0
                ])
                    hueco_switch(grosor_placa);
    }
}

placa_switches();

Con difference restamos los 18 huecos de la base. Cambiando la lista stagger ajustas la ergonomía sin tocar nada más; eso es exactamente la ventaja de parametrizar que vimos en el artículo 2.4. Las tres teclas de pulgar se añaden con su propio bloque y su ligera rotación, siguiendo la misma idea.

Carcasa high-profile

Un case high-profile envuelve los switches con una pared que sube por encima de la placa, dando un acabado limpio y rigidez. Lo construimos como un marco hueco: una placa redondeada exterior menos un vaciado interior, dejando un reborde donde apoya la switch plate.

use <lib/cutouts.scad>   // reutilizamos los cutouts del caso 2.6

alto_case   = 16;     // altura de la pared high-profile
pared_case  = 3;
apoyo_placa = 11;     // a qué altura descansa la switch plate

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);
}

module case_highprofile(l, w) {
    difference() {
        placa_redondeada(l, w, alto_case, 4);

        // vaciado interior principal
        translate([pared_case, pared_case, -1])
            placa_redondeada(
                l - 2 * pared_case,
                w - 2 * pared_case,
                alto_case + 2, 3);

        // rebaje superior donde apoya la switch plate
        translate([pared_case - 1.5, pared_case - 1.5, apoyo_placa])
            placa_redondeada(
                l - 2 * pared_case + 3,
                w - 2 * pared_case + 3,
                alto_case, 3);
    }
}

El doble vaciado crea un escalón interior: la parte estrecha aloja la electrónica y el reborde superior sostiene la placa de switches a la altura apoyo_placa.

Pasacables entre mitades

Un teclado split necesita un cable (normalmente TRRS, el mismo jack de cuatro contactos de unos auriculares con micrófono) que una las dos mitades, además del USB-C que va al ordenador. Aquí es donde reutilizamos la biblioteca de cutouts del caso anterior sin reescribir nada:

module cut_trrs(holgura = 0.3, profundidad = 6) {
    // Jack TRRS: taladro de 6 mm
    translate([0, -1, 0])
        rotate([-90, 0, 0])
            cylinder(h = profundidad, d = 6 + holgura, $fn = 40);
}

// dentro del difference del case:
//   USB-C hacia el ordenador (reutilizado de lib/cutouts.scad)
translate([20, pared_case, 8]) cut_usbc(0.3);
//   TRRS hacia la otra mitad
translate([55, pared_case, 8]) cut_trrs(0.3);

El cut_usbc es exactamente el módulo que definimos en el artículo 2.6: lo importamos con use <lib/cutouts.scad> y lo colocamos con un translate. Esa es la recompensa de haber construido una biblioteca: el segundo proyecto cuesta mucho menos que el primero.

Mirror para la otra mitad

Como el teclado es split y simétrico, la mitad derecha es el espejo de la izquierda. OpenSCAD lo resuelve con mirror, evitando duplicar el diseño:

// mitad izquierda
case_highprofile(140, 95);

// mitad derecha: espejo respecto al plano YZ
translate([200, 0, 0])
    mirror([1, 0, 0])
        case_highprofile(140, 95);

Lo que te llevas de este caso

• Una placa de switches es una rejilla de huecos de 14 x 14 mm con paso 19.05 mm; el stagger por columna es una simple lista.
• Un case high-profile se modela como un marco con doble vaciado que crea el apoyo para la placa.
• La biblioteca de cutouts del caso anterior se reutiliza tal cual: USB-C y TRRS sin reescribir.
• mirror genera la mitad simétrica gratis.

Modelar un teclado a mano funciona, pero cuando el stagger, los ángulos y las columnas se complican, hay una herramienta especializada que genera toda esta geometría desde un YAML: Ergogen, que veremos a continuación.