Framework para Modelos SBC

Para aquellos que crean diseños con un SBC o microcontroladores, contar con un modelo puede ser algo muy importante. Quisiera compartir un framework simple, liviano y dinámico para la generación de modelos de microcontroladores y de SBC escrito en OpenSCAD. Cuando originalmente creé el modelo OpenSCAD XU4 hace un par de años, https://forum.odroid.com/viewtopic.php?f=97&t=26243, era un modelo estático codificado y el único SBC que tenía. Funcionaba bien por aquel momento, pero desde entonces he adquirido algunos SBC más y he tenido la necesidad de acceder a diferentes modelos mientras trabajaba en varios proyectos.

En el proyecto actual en el que estoy trabajando intervienen múltiples SBC, por lo que decidí hacer una pausa y desarrollar los modelos para el resto de SBC involucrados. La creación de modelos para toda la línea de HK había estado en mi lista de proyectos durante algún tiempo, pero nunca llegaron a tener la prioridad suficiente como para completarlos

En lugar de hacer un modelo predeterminado para todos, decidí que sería mejor crear un framwork que pudiera manejar múltiples SBC y microcontroladores. Este método me permite acceder a todos ellos a través de una única llamada de módulo, manteniendo pequeño y eficiente el código. Esto es importante para mí, ya que los grandes y complejos ensamblajes pueden tardar un tiempo considerable en compilarse en OpenSCAD. A modo de comparación, recientemente he estudiado un modelo STEP y DXF similar al de Odroid H2 de HK. El modelo STEP era de 993 KB y el tamaño del archivo DXF era de 1,273 KB. Puede que no sea especialmente grande para un modelo 3D estático, pero cuando hay involucrados varios modelos, puede empezar a ser significativo. En cambio, todo el código y el conjunto de datos SBC utilizados en este framwork, que representa 8+ SBCs, suponen un total de 83 KB y la eficacia de este método solo aumentará a medida que se agregan más modelos.

Para mí, el criterio más importante en la mayor parte de mi trabajo está relacionado con las dimensiones físicas, de modo que la ubicación y la verificación se pueden realizar de forma rápida y sencilla a medida que desarrollo los diseños. Para que las cosas sean lo más precisas posible, la información para los modelos procede de los planos de diseño mecánico 2D suministrados por HK y de las mediciones reales de los SBC que poseo. En los casos en los que no dispongo de un SBC en particular, uso las especificaciones técnicas de los componentes suministrados por el fabricante. Cuando el fabricante de los componentes no es conocido, comparo las especificaciones técnicas de varios fabricantes para generalizar el diseño de un componente.

La estética no es tan importante para mí como lo es el tamaño del código o la velocidad de procesamiento, de modo que es algo secundario en este framework. Dicho esto, he dedicado tiempo a desarrollar mejores modelos de componentes así que son más completos y se ven mejor que los componentes del modelo XU4 original. Mantendré y agregaré a esta librería de SBC según sea necesario o cuando haya disponibles otros SBC de HK.

Actualmente los SBC soportados y completados son: ODROID-C1+, ODROID-C2, ODROID-XU4, ODROID-N1, ODROID-N2, ODROID-MC1, ODROID-HC1, ODROID-HC2 y ODROID-H2 de Hardkernel

A veces, solo son necesarias las dimensiones de la placa y la disposición de los huecos para un diseño especifico y éstos se puede añadir rápida y fácilmente a este framework editando el archivo de configuración ASCII. Hice esto para probar el procedimiento en los siguientes SBC:

Modelos 3B+, 3B, 3A+, 2, 1A+ de la fundación Raspberry Pi Pine64’s A64, Rock64, RockPro64.

Usando el Framework

Se puede llamar a cualquiera de los modelos pasando el modelo SBC solicitado en forma de sbc (“xu4”). A continuación, se muestra un código de ejemplo que fue utilizado para generar la imagen de apertura.

Test.scad
include

translate ([-120,0,0]) sbc("xu4");
linear_extrude(height = 2) {translate([-120,-20,0]) text("Odroid XU4");}
translate ([-120,110,0]) sbc("c2");
linear_extrude(height = 2) {translate([-120,90,0]) text("Odroid C2");}
translate ([-120,200,0]) sbc("c1+");
linear_extrude(height = 2) {translate([-120,180,0]) text("Odroid C1+");}
translate ([0,0,0]) sbc("n1");
linear_extrude(height = 2) {translate([0,-20,0]) text("Odroid N1");}
translate ([0,120,0]) sbc("hc1");
linear_extrude(height = 2) {translate([0,100,0]) text("Odroid HC1/HC2");}
translate ([0,200,0]) sbc("mc1");
linear_extrude(height = 2) {translate([0,180,0]) text("Odroid MC1");}
translate ([120,120,0]) sbc("h2");
linear_extrude(height = 2) {translate([120,100,0]) text("Odroid H2");}
translate ([120,0,0]) sbc("n2");
linear_extrude(height = 2) {translate([120,-20,0]) text("Odroid N2");}
Un componente de un SBC que no es necesario o necesita ser deshabilitado temporalmente, puede excluirse añadiendo un signo menos a su entrada de clase en el archivo sbc_models.cfg. Un ejemplo de este uso podría aplicarse al emmc. Tanto el emmc como la clavija (conectados a la PCB) están disponibles. A continuación, se muestra una ilustración del XU4 para desactivar la visual del emmc mientras se muestra el conector del emmc.
// Hard Kernel ODROIDs
["xu4",83,59,1,3.5,17,6, // sbc model, pcb size and component height
3.5,3.5,3,3.5,55.5,3, // pcb holes 1 and 2 location and pcb hole size
79.5,3.5,3,79.5,55.5,3, // pcb holes 3 and 4 location and pcb hole size
79.61,22,3,28.39,42,3, // pcb holes 5 and 6 location and pcb hole size
0,0,3.3,0,0,3.3, // pcb holes 7 and 8 location and pcb hole size
0,0,0,0,0,0, // pcb holes 9 and 10 location and pcb hole size
14.5,15.75,1.25,59.7,20.55,0,0,"top", // soc1 size, location, roation and side
0,0,0,0,0,0,0,"", // soc2 size, location, roation and side
0,0,0,0,0,0,0,"", // soc3 size, location, roation and side
0,0,0,0,0,0,0,"", // soc4 size, location, roation and side
47.5,13.7,0,"bottom","memory","emmc_plug", // emmc plug location, rotation, side, class and type
45,0,0,"bottom","-memory","emmc", // emmc location, rotation, side, class and type
45.85,5,0,"top","storage","sdcard", // sdcard location, rotation, side, class and type
79,7.15,0,"top","switch","slide_4x9", // switch location, rotation, side, class and type
25.925,52.925,0,"top","button","momentary_6x6x9", // pwrbutton location, rotation, side, class and type
34.85,-1,0,"top","plug","pwr5.5_7.5x11.5", // pwrplug location, rotation, side, class and type
26,0,0,"top","usb2","single_vert_a", // usb2 location, rotation, side, class and type
7.55,41.6,180,"top","usb3","double_stacked_a", // usb3 location, rotation, side, class and type
7.4,0,0,"top","network","rj45_single", // ethernet location, rotation, side, class and type
60,-1,0,"top","video","hdmi_a", // hdmi location, rotation, side, class and type
0,37.8,90,"top","plug","uart_micro", // uart location, rotation, side, class and type
0,25,270,"top","plug","rtc_micro", // rtc location, rotation, side, class and type
27,22,90,"top","fan","micro", // fan location, rotation, side, class and type
35.4,52.25,0,"top","gpio","encl_header_30", // gpio1 location, rotation, side, class and type
76.25,32.5,270,"top","gpio","encl_header_12", // gpio2 location, rotation, side, class and type
43.8,27.25,0,"top","ic","ic_5.75x5.75", // pmic location, rotation, side, class and type
32.5,40.5,0,"top","ic","ic_7x7", // usbhum 7mm location, rotation, side, class and type
11.7,22.8,0,"top","ic","ic_6x6", // nic location, rotation, side, class and type
0,0,0,"*","*","*"], // end

Modificar y añadir componentes

El framwork está configurado para que tanto los SBC como los componentes puedan añadirse o modificarse fácilmente y los modelos resultantes se puedan usar independientemente del estado final. El framework consta de tres partes, el conjunto de datos SBC (sbc_models.cfg), el módulo principal (sbc_models.scad) y una librería de componentes (sbc_library.scad).

sbc_models.cfg es un archivo ASCII que se puede modificar con cualquier editor de texto. Contiene un conjunto de datos sobre la descripción de un supuesto SBC. El esquema es el siguiente

"model",pcbsize_x, pcbsize_y, pcbsize_z, pcbcorner_radius, topmax_component_z, bottommax_component_z
pcb_hole1_x, pcb_hole1_y, pcb1_hole_size, pcb_hole2_x, pcb_hole2_y, pcb2_hole_size
pcb_hole3_x, pcb_hole3_y, pcb3_hole_size, pcb_hole4_x, pcb_hole4_y, pcb4_hole_size
pcb_hole5_x, pcb_hole5_y, pcb5_hole_size, pcb_hole6_x, pcb_hole6_y, pcb6_hole_size
pcb_hole7_x, pcb_hole7_y, pcb7_hole_size, pcb_hole8_x, pcb_hole8_y, pcb8_hole_size
pcb_hole9_x, pcb_hole9_y, pcb9_hole_size, pcb_hole10_x, pcb_hole10_y, pcb10_hole_size
soc1size_x, soc1size_y, soc1size_z, soc1loc_x, soc1loc_y, soc1loc_z, soc1_rotation, "soc1_side",
soc2size_x, soc2size_y, soc2size_z, soc2loc_x, soc2loc_y, soc2loc_z, soc2_rotation, "soc2_side",
soc3size_x, soc3size_y, soc3size_z, soc3loc_x, soc3loc_y, soc3loc_z, soc3_rotation, "soc3_side",
soc4size_x, soc4size_y, soc4size_z, soc4loc_x, soc4loc_y, soc4loc_z, soc4_rotation, "soc4_side",
component_x, component_y, component_rotation, "component_side", "component_class","component_type"
Parte del esquema tiene una longitud fija e incluye el modelo SBC, el tamaño xyz de PCB, el radio de la esquina, las alturas máximas de los componentes superior e inferior, hasta 10 orificios y hasta 4 SOC. Esta parte del esquema tiene la misma longitud para todas las definiciones del SBC. El número de entradas de componentes es ilimitado en cantidad y lo tratare en un minuto. Creo que los datos básicos de PCB se explican por sí mismos. Las dimensiones físicas (xyz) se deben conocer para crear un PCB. La altura máxima del componente Z superior e inferior puede ser útil para los diseños que utilizan esta librería. Los orificios de la PCB están limitados a 10 definidos por su diámetro y ubicación del centro xy. El número se puede ampliar fácilmente si llega a convertirse en un inconveniente.

He decidido incorporar varios SOC y no incluirlos como un componente por un par de razones. Ya hay SBC que están especializados e incluyen múltiples unidades de procesamiento. Me refiero a todos ellos en este framework como SOC, aunque también podrían ser microcontroladores, procesadores de AI o procesadores de comunicación dedicados en la PCB, por nombrar algunos. Al definirlos por separado de los componentes, se puede incluir información adicional como el tamaño y la altura sin cargar cada entrada de componente con esta información adicional. Cuatro entradas deberían ser suficientes, aunque también se pueden ampliar fácilmente en el futuro sin una modificación significativa del programa. Las entradas de SOC pueden rotar y también se pueden colocar a ambos lados de la PCB. Si no es necesario un hueco o SOC, deja los valores escalares a cero y las entradas de texto vacías.

La última entrada en el esquema es para los componentes. Un componente es cualquier cosa que se conecta a la PCB. Se puede colocar cuantos componentes se quiera desde la librería por SBC. El algoritmo colocará automáticamente tantos o tan pocos como se definan. Hay seis valores por componente. La ubicación del componente xy para la parte superior de la PCB se mide desde la esquina inferior izquierda de la PCB hasta la esquina inferior izquierda del componente o abertura, con los orificios medidos hacia el centro. Los componentes del lado inferior se miden desde la esquina superior izquierda hasta la esquina superior izquierda del componente, cuando la PCB rota alrededor del eje x. Todas las medidas están en mm y, como regla general, la orientación de la PCB es con el lado más amplio de la PCB a lo largo del eje x.

El valor de rotación no hace girar el componente alrededor de la ubicación xy. Es una referencia a la dirección en la que el anverso del componente y cualquier esquina del componente que se encuentre en el extremo inferior izquierdo después de la rotación, asumirá la ubicación xy especificada para la entrada del componente. Esta es una manera uniforme de medir la ubicación de los componentes independientemente de su orientación en la PCB. La entrada del esquema etiquetada con component_side es el lado del PCB en el que se colocará el componente. Hasta ahora hemos cubierto component_x, component_y, component_rotation y component_side. Las dos últimas entradas son component_class y component_type. Estas entradas juntas determinan el componente a colocar. Cada clase de componente contiene uno o más tipos de componentes. Actualmente existen 17 clases de componentes con los tipos de componentes correspondientes:

  • memory – emmc, emmc_plug, sodimm_5.2, sodimm_9.2
  • switch – slide_4x9
  • button – momentary_6x6x9, momentary_6x6x4
  • plug – pwr5.5_7.5×11.5, pwr2.5_5x7.5, rtc_micro, uart_micro, molex_4x1, small_encl_satapwr
  • usb2 – single_vert_a, double_stacked_a, micro
  • usb3 – double_stacked_a
  • network – rj45_single
  • video – hdmi_a, dp-hdmi_a
  • fan – micro, encl_pmw
  • gpio – encl_header_30, encl_header_12, header_40, header_20
  • ic – ic_2.8×2.8, ic_4.7×4.7, ic_5x5, ic_5.75×5.75, ic_6x6, ic_6.75×6.75, ic_7x7, ic_6.7×8.4, ic_11x8, ic_13x8
  • audio – out-in-spdif, jack_3.5
  • storage – sata_header, sata_encl_power, sata_encl_header, m.2_header, sdcard
  • combo – rj45-usb2_double, rj45-usb3_double
  • jumper – header_2x1, header_7x1
  • misc – ir_1

En resumen, los nuevos SBC se definen en sbc_model.cfg y los nuevos componentes se añaden a sbc_library.scad. Para agregar un SBC, modifica sbc_models.cfg creando o copiando una entrada de SBC existente. Actualiza los componentes y datos relativos al SBC para el nuevo SBC. Cuando sea necesario añadir un tipo de componente, simplemente agrega el código que traza este tipo de componente en el módulo clase al que pertenece el componente, ubicado en sbc_library.scad. No hay comprobación ni validación de ningún tipo, de modo que realmente cualquier clase puede contener cualquier tipo de componente. Los nombres son simplemente los que yo he elegido para que la estructura tenga sentido para mí en un futuro.

OpenSCAD tiene la posibilidad de exportar modelos a otros formatos, así que, a través de la exportación y la posible traducción, otros sistemas CAD también pueden usar estos modelos. Si tiene alguna pregunta o problema, o desea contribuir con datos o componentes de SBC a la librería, escribe un post o envíeme un Mensaje Privado. Mantendré esta librería y publicaré cualquier SBC y componente adicional en el hilo del foro. https://forum.odroid.com/viewtopic.php?f=98&t=33823

Para aquellos interesados en probar este framework de modelo SBC, recomiendo una versión más reciente de OpenSCAD que esté disponible en su repositorio snapshot en http://files.openscad.org/snapshots/.

Incluso hay una aplicación armhf reciente que he verificado que funciona en un XU4 con Ubuntu 18.04. Desafortunadamente, no está acelerada por hardware, por lo que es lenta para los diseños de un tamaño significativo. Recientemente intenté compilar la fuente para el XU4. Se pudieron cubrir todas las dependencias, pero hubo un problema con desajustes de la declaración de opengl. En mi breve investigación, esto es normal y parece resolverse usando Glew u otra herramienta. Por ahora es un problema poco prioritario para mí, pero me gustaría que la aceleración de hardware funcionara para OpenSCAD sobre los Odroids en el futuro.

Be the first to comment

Leave a Reply