PCBs con el paint, paciencia y dosis de cutrez

Creo que después de tantos retoques al artículo del portapack iba tocando hacer un post nuevo. La gente cercana suele decir que soy un poco rata, eso es un bulo sin fundamentos. De todos modos, sin tener relación alguna, voy a enseñaros cómo he hecho últimamente algunas placas de “prototipo” (permanente) con placas de prototipos para soldar y de forma barata.

1. Preludio al cutrismo

El primer motivo para ello es que a veces necesitas algo concreto y no lo venden ya montado. El segundo que si viene montado cuesta 4x de lo que costaría ensamblarlo a mano (ahí tenemos los módulos de flipper zero a 40 o 50€ con 3-4 módulos de arduino que cuestan 2-3€ cada uno).

Y claro, tú pensarás que porque no diseñar las placas y mandarlas a PCBWay para que me las fabriquen y ya soldar los componentes con una placa en condiciones… Pues porque… ¡Aquí el espiritu es ser cutre, vago, rata y desordenado!

Y es que en aliexpress tienes 10 placas para soldar prototipos por menos de 2€:

Siempre las pido de ese tamaño, es perfecto, es más que suficiente para satisfacer a un maker, todo lo demás es vicio, perversión y socialismo.

Yo siempre las he usado mucho para pasar cosas de la protoboard a cosas que quiero que no se desmonten ya. Aunque es verdad que alguna la he “deshecho”, igual en un futuro escribo un artículo explicando como quito los componentes soldados de una. La cuestión es que uno acaba harto de tener la protoboard con cables colgando y los modulos ahí pinchados, porque son más aparatosos y a la mínima están fallando las conexiones o soltándose cosas. De verdad, que es un coñazo si es algo que no quieres desmontar, y he llegado a tener prototipos así durante varios meses jaja

Antes lo que hacía era soldar los módulos con la suficiente separación para poder juntar los pines con los cables y luego ir cableando. Y toda la placa era con cablecitos por encima. Pero esto es tremendo rollo y además tiene más riesgo de fallos.

Cuando hablo de tener la suficiente separación me refiero a dejar un agujero para el pin y uno circundante para unirlo al cable u otro pin. Es algo que veremos ahora.

Voy a aprovechar un proyecto de APRS con Lora para enseñaros el proceso que sigo para realizar el diseño y construcción. Dejo debajo el enlace a wikipedia de APRS, básicamente es un sistema para mandarse mensajes automátizados por radio, pero una de las cosas más típicas es usarlo para ir mandando paquetes con la posición GPS del cacharro.

Los radiofrikis usan esto por hacer pruebas de alcance. Sólo hay que metérselo en el bolsillo e ir a andar, luego vas a internet y ves si quién ha recibido tus paquetes 😀. Además usando lora se consiguen distancias sorprendentes con poca potencia y hardware barato (y eso nos gusta).

Me viene bien porque esto se divide en dos proyectos:

1. Un geolocalizador que envía la posición GPS por lora (APRS Lora Tracker)
2. Una estación lora que recibe los paquetes y los reporta por internet (APRS Lora iGate)

En el caso de este artículo ya tenía hecho el tracker, que me ha dado problemas pero funciona, que hice con el método coñazo de ir poniendo cablecitos. Así que me centraré en el iGate/digipeater.

Y bueno, aprovecho para enseñar que uno muchas veces puede coger un proyecto FLOSS sin miedo y adaptarlo a sus necesidades. Ya que me tocó añadir ciertos cambios muy sencillos al código.

Para que haya una referencia del método anterior pongo fotos de como está montado el tracker:

Se puede ver que tiene demasiados cablecitos para unir los módulos. Lo desmonto para que se vea todo (ignoremos los destrozos que le he hecho a la placa y a la caja con el minitaladro):

Y si enseño la placa por detrás se puede ver que toda la lógica de “pistas” son los cables que van por la cara de arriba y aquí hay poco que rascar:

Además de ser incómodo de “fabricar” así, luego cuesta más de buscar fallos con el polímetro porque los cables se enmarañan algo. Esto nos lleva al proceso que voy a explicar y con ello acabo esta introducción densa.

2. Poniendo el foco en el proyecto que nos incumbe

Como he mencionado antes, el proyecto en el que me centraré es en el iGate que se encuentra en GitHub.

Este proyecto tiene un montón de placas configuradas para poder programar, pero yo decidí crearlo a mano usando el esp32-c3 supermini y asignando yo las conexiones que vi que funcionaban sin problemas. Esta placa está chiquita como podrías suponer por su nombre y es especialmente barata. Eso sí, los pines son limitados, hay que dosificarlos como si realmente fuesen caros.

El proyecto está hecho con PlatformIO. Tuve que modificar y añadir alguna cosilla. ¡Eso es lo guay del FLOSS!

Aquí una traza del diff para qué podáis ver los cambios que apliqué para que funcionase:

--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -77,6 +77,8 @@ jobs:
                       chip: esp32c3
                     - name: QRPLabs_LightGateway_1_0
                       chip: esp32s3
+                    - name: ESP32_C3_SUPERMINI
+                      chip: esp32c3
         steps:
             - uses: actions/checkout@v3

--- a/platformio.ini
+++ b/platformio.ini
@@ -480,6 +480,29 @@ build_flags =
     -DHAS_SX1262
        -DARDUINO_USB_MODE=1
        -DARDUINO_USB_CDC_ON_BOOT=1
 lib_deps =
        ${common.lib_deps}
        ${common.display_libs}
+[env:ESP32_C3_SuperMini]
+board = lolin_c3_mini
+build_flags =
+       ${common.build_flags}
+       -DESP32_C3_SUPERMINI
+       -DHAS_SX1278
+       -DARDUINO_USB_MODE=1
+       -DARDUINO_USB_CDC_ON_BOOT=1
+lib_deps =
+       ${common.lib_deps}
+       ${common.display_libs}

--- a/src/boards_pinout.h
+++ b/src/boards_pinout.h
@@ -187,7 +187,7 @@
 #endif


-#if !defined(HELTEC_HTCT62) && !defined(HELTEC_WSL_V3) && !defined(ESP32C3_DIY_1W_LoRa) && !defined(ESP32C3_DIY_1W_LoRa_915) && !defined(WEMOS_S2_MINI_DIY_LoRa)
+#if !defined(HELTEC_HTCT62) && !defined(HELTEC_WSL_V3) && !defined(ESP32C3_DIY_1W_LoRa) && !defined(ESP32C3_DIY_1W_LoRa_915) && !defined(WEMOS_S2_MINI_DIY_LoRa)
     #define HAS_DISPLAY
 #endif

@@ -277,6 +277,35 @@
     #define RADIO_BUSY_PIN      8
 #endif

+#if defined(ESP32_C3_SUPERMINI)
+    // intentar evitar usar 2 (boot mode / strapping pin), 8 (Blue status_led (inverted), boot mode / strapping pin) y 9 (Boot mode / strapping pin, boot button)
+    #define RADIO_SCLK_PIN   4
+    #define RADIO_MISO_PIN   5
+    #define RADIO_MOSI_PIN   6
+    #define RADIO_CS_PIN     7
+    #define RADIO_RST_PIN    3
+    #define RADIO_BUSY_PIN  10
+    #define OLED_SDA         0
+    #define OLED_SCL         1
+    #define OLED_RST        -1
+    //#define GPS_TX          20
+    //#define GPS_RX          21
+#endif
+
 #ifdef LIGHTGATEWAY_1_0
     #define BUTTON_PIN          0
     #define INTERNAL_LED_PIN    16

--- a/src/power_utils.cpp
+++ b/src/power_utils.cpp
@@ -205,7 +205,7 @@ 
namespace POWER_Utils {
             Wire1.begin(BOARD_I2C_SDA, BOARD_I2C_SCL);
         #endif

-        #if defined(HELTEC_V3) || defined(HELTEC_WS) || defined(LIGHTGATEWAY_1_0) || defined(TTGO_LORA32_T3S3_V1_2)
+        #if defined(HELTEC_V3) || defined(HELTEC_WS) || defined(LIGHTGATEWAY_1_0) || defined(TTGO_LORA32_T3S3_V1_2) || defined(ESP32_C3_SUPERMINI)
             Wire.begin(OLED_SDA, OLED_SCL);
         #endif

Voy a confesar que es posible que haya alguna errata ahí arriba, he toqueteado el diff un poco a lo juan palomo. Pero bueno, en resumen los cambios serían:

1. Añadir un nuevo entorno (env) con nuestra placa y lo que haga falta configurarle.
2. Definir los pines que usará nuestra placa para la macro definida en el punto 1 (ESP32_C3_SUPERMINI).
3. Usar esa misma macro si hace falta para configurar otras cosas, en este caso he tenido que usarla para decirle que use pines customizados para la pantalla oled y para decirle que evidentemente tiene pantalla oled.

Y es que platformIO es una maravilla, ahora puedo elegir esa placa que he configurado y ya compila e instala todo lo necesario para que funcione. Shame on you arduino, shame on you…

Se puede ver que en un principio pensé en añadirle el módulo de GPS pero esto ni he probado si funcionaba porque me da un poco igual. Pero en general, antes de pasar al siguiente punto de este post, lo suyo sería haber probado que el código funciona bien usando la protoboard con los cablecitos. Los cablecitos dan asco, fallan mucho, dan problemas pero… ¡Se pueden quitar y cambiar fácil! ¡Una vez sueldes las cosas te vas a lamentar si falla!

3. Diseñando con el paint

No acabo de encontrar una herramienta para linux que me sea tan cómoda para cosas sencillas como el paint de marras. Está inkscape pero tiene tantas cosas que, para algo simple, me da hasta pereza abrir el programa.

Para empezar a “diseñar” primero creo la cuadricula que representan los puntos soldables y los módulos con el tamaño que ocupan según esa cuadrícula. Asegurándome bien de que los pines encajen bien en los cuadrados y también el tamaño y distancia de estos. Así no hay problemas luego al pasarlos a la realidad y que tropiecen los módulos.

Para diseñar los módulos suelo partir de una cuadricula, poner los pines y luego el contorno que ocupan. Y le añado algún detallito para que se vea lo que es y también la leyenda de cada pin, que esto ayudará luego a cablear/hacer las pistas.

Antes de ponerme a hacer pistas sobre la cuadricula las hago sin guía para hacerme una idea para probar a conectar todo sin engorros. La idea al diseñar pistas es que tienes que conectar todo sin que una pista atraviese a otra. Por lo tanto cada pista que añades va limitando las siguientes, el orden y la posición de los elementos afecta bastante.

Para este circuito, como ya he mencionado, voy a usar una placa “esp32-c3 supermini”. Este es un caso particular, ya que esta placa se puede soldar directamente sobre los pads de cobre de una pcb, así que por eso si os fijáis en la parte de arriba lo he puesto por la parte de arriba y por la de abajo. Por ver cómo me pillaba mejor para ahorrar espacio.

Con pad me refiero a cada uno de los circulitos de cobre por dónde se pasan los pines/cables y se sueldan, cada pad es un cuadradito de nuestra cuadrícula.

Para las conexiones hay que ir fijándose en los pines definidos en el código que he enseñado en el punto anterior.

Aquí un posible diseño:

Las reglas más o menos son:

1. Las pistas nunca deben pisarse, si se pisan estás cortocircuitándolas y a efectos prácticos son la misma conexión. El único caso que véis ahí que se pisa, al que le he puesto una línea más fina, es porque haré un “puente”. Es decir: voy a sacar un cable hacía arriba para poder saltar por encima de las pistas. Hay que evitar los puentes siempre que se pueda, cuantos menos de estos, más calidad y más cómodidad luego.
2. Las pistas no pueden pasar por debajo de pines, esos pines irán soldados a un pad y como enseñaré luego, los pads nos servirán para trazar las pistas saltando de uno a otro. Por lo que el pad de esa posición está ocupado.
3. Las pistas girarán en ángulos rectos. Fun fact: si el profesor que me enseñó a diseñar PCBs con el orcad viese esto me mataría jajaja porque al diseñar pistas siempre te dicen que hay que diseñar pistas sin ángulos rectos (si no recuerdo mal porque los ángulos demasiado cerrados actuaban como un condensador y afectaba al circuito). Pero creéme que te hará falta, en diagonal no vas a poder juntar pads y no acaba de ser un ángulo estrictamente recto al final.
4. No confíes en que este primer esbozo te sirve, es para orientarte en cómo ubicar las cosas sobre el tablero. Pero luego con la pcb tienes más limitaciones para hacer pistas en cuanto a longitud y cantidad.

Aquí la herramienta de recorte con fondo transparente va a ser tu nuevo dios para sobreponer unas cosas encima de otras.

Aquí os enseño cómo quedó el diseño que hice:

Si os fijáis, he puesto la misma imagen pero la segunda está en espejo. Esto es porque a la hora de crear las pistas con el soldador nos vamos a guiar por esta segunda imagen, ya que le daremos la vuelta. ¡La primera para diseñar sin líarnos! Y una vez esté se transforma a espejo.

Para crear las pistas (supongo que no es necesario especificar que usando el soldador) lo que yo hago es ir haciendo una bolita en cada pad y luego ir uniéndolas con la calmita. Hay que esperar a que vaya enfríando cada unión para juntarlas entre ellas. Si está todo caliente se separarán. En aspectos generales la técnica consiste en hacer todo tipo de cosas por las que un ingeniero electrónico se llevase las manos a la cabeza al verte jaja

Aquí se puede ver el resultado por ambos lados, que se ve mucho más limpio que el anterior con tanto cable:

He grabado un video haciendo toda la placa y lo he puesto a 2x, no es que sea de mucha calidad pero si alguien quiere verlo lo he subido a YouTube, mejor explicación que verlo no hay:

El espacio asignado para subir posts a este blog es de sólo 1 GiB y claro, no cabe el video. Así que a partir de ahora, ¿quién sabe si ahora me dará por subir algún video más a youtube? Igual hasta en alguno hablo jajaj

Espero que os haya gustado este post y le haya servido a alguien. ¡Hasta el próximo!

Enlaces de interés

• APRS
• GitHub de Lora APRS tracker
• GitHub de Lora APRS iGate