Kit Compañero Arduino Nano: Componentes y Herramientas Esenciales para Electrónica DIY

Componentes y suministros

Arduino Nano R3	×	1
Cable USB-A a Mini-USB	×	1
Resistencia 10k ohm (incluye 2x 220 ohm, 1x 1k, 4.7k, 47k, 100k ohm)	×	4
Potenciómetro monoturno 10k ohm	×	1
Pulsador SparkFun 12mm	×	2
Interruptor deslizante	×	3
Conector hembra 8 posiciones 1 fila (0.1")	×	4
Conector macho 36 posiciones 1 fila - Largo (0.1")	×	2
LCD RGB con retroiluminación Adafruit 16x2	×	1
Portapilas 4xAA	×	1

Herramientas necesarias

• Soldador (genérico)
• Pistola de pegamento caliente (genérica)

Sobre este proyecto

El Companion IC es un dispositivo multifunción muy atractivo: Reloj + Medidor de resistencia + Medidor de capacitancia + Probador de diodos. Se enciende pulsando el Pin 1 del IC. Mantenlo en tu banco de trabajo para pruebas rápidas de componentes y consulta de la hora. Puede funcionar con pilas o mediante USB si tienes una fuente cerca.

Siempre quise publicar un proyecto pero nunca encontré nada único hasta ahora. La idea surgió cuando quise probar unos condensadores para ver si estaban defectuosos. Solo tenía un multímetro sin función de medición de capacitancia. Al investigar, descubrí que Arduino puede hacerlo. Decidí hacer uno, pero ver los pines sin usar del Arduino no me satisfacía, así que añadí un ohmímetro autoranging, probador rápido de LED/diodos y reloj RTC. También quería medir valores enchufando directamente el componente, sin sondas. El diseño tenía que ser único, así que tras lluvias de ideas nació el diseño en forma de IC.

Edit (07/01/2016): Se ha añadido prueba de continuidad opcional, ver sección de comentarios.

Este artículo explica en gran detalle cómo lo hice y cómo tú también puedes hacerlo. Es apto para principiantes: cualquiera con 2-3 semanas de experiencia en Arduino/Electrónica puede construirlo. El diseño es modificable: puedes añadir/quitar funciones según tus necesidades. Yo hice la carcasa con cartón, pero si tienes habilidades, puedes usar madera o imprimirla en 3D.

He intentado fotografiar cada paso (¡muchas fotos en cada paso!). La mayoría se tomaron varias veces hasta conseguir el mejor ángulo/luz, pero algunas están un poco borrosas porque sostener todo con dos manos a veces es difícil.

He dividido todo el código y cableado en piezas y pasos, tal como lo construí. El código incluido está fuertemente comentado e indentado correctamente. A medida que avancemos, combinaremos todo el código y cableado paso a paso para crear el IC final. Esto debería ayudar a cualquiera a entenderlo claramente. Si no, avísame en los comentarios.

Incluso si decides no construirlo, pruébalo en protoboard o al menos léelo una vez: debe haber algún método, truco o algo que puedas aprender y que te sea útil algún día (en serio, nunca sabes cuándo hará "clic"!).

Paso 1: Herramientas y componentes necesarios

Lista de componentes y materiales (enlaces de tienda solo como referencia):

• 1x Arduino Nano V3, usé un clon con CH340G -- eBay
• Cable Mini USB para Arduino Nano -- Mini no Micro!
• Cartón -- usé una caja de embalaje, grosor ~2mm. Pide a vecinos, amigos, busca si no encuentras.
• 4x Resistencia 10k ohm -- fácil de conseguir
• 2x Resistencia 220 ohm -- fácil de conseguir
• 1x Resistencias (1k, 4.7k, 47k, 100k) ohm -- fácil de conseguir
• 1x Potenciómetro pequeño 10k ohm, para control de contraste del LCD... cualquier uno pequeño sirve -- eBay
• 2x Micropulsador, para reset y cambio de modo, los comunes de protoboard
• 3x Interruptores deslizantes pequeños, para activar retroiluminación, pines 0 y 1, estos pines deben desactivarse al usar Serial -- eBay
• 1x Pulsador maintained/toggle/latching, para interruptor de encendido -- eBay
• Algunos condensadores, diodos, LEDs solo para probar, los usarás algún día.
• 4x Tira de conectores hembra -- eBay (40 pines por tira)
• 2x Tira de conectores macho -- eBay (40 pines por tira)
• 1x LCD 16x2 caracteres -- eBay
• 1x Módulo RTC DS3231 o DS1307 (RTC = Real Time Clock) -- No compres baratos en eBay. Usan chips falsos y son inexactos. Compra este, este o este. Cualquiera funcionará.
• 4x Pilas AA (o AAA. Usar AAA será más fácil pero la capacidad es menor)
• 1x Portapilas 4 AA (o AAA), variante plana -- eBay
• Hilo unifilar, los de protoboard, 22 AWG
• Cable plano (o cables de par trenzado fino) -- eBay
• 2x Tuerca y tornillo pequeños -- usé los de mi viejo Meccano (tornillos 1.3cm)
• Pintura acrílica negra y pinceles

Herramientas necesarias:

• Soldador
• Estaño
• Malla desoldadora (para cuando la líes!)
• Pistola de pegamento
• Cinta de carrocero
• Cinta adhesiva transparente
• Pelacables, alicates
• Cúter afilado
• Tijeras afiladas

Paso 2: Ohmímetro - Concepto

La idea básica de medir resistencia proviene del divisor de tensión.

Los valores de las resistencias son modificables: cambia valores de r1, r2, etc. También establece los rangos (para autoranging) entsprechend. Ver código abajo, descárgalo de los archivos al final y prueba el ohmímetro en protoboard.

Si configuras el Nano por primera vez, el driver CH340G puede descargarse aquí, funciona con Windows 7, 8, 8.1 y 10. Usuarios de Mac ver aquí.

Selecciona "Arduino Nano" en menú de placas y el puerto COM correcto. ¡Sube!

Código Ohmímetro

// Pin analógico para encontrar resistencia
int Apin=7;
// valores de r1 a r5
float r1=1000;
float r2=4700;
float r3=10000;
float r4=47000;
float r5=100000;
// pines de r1 a r5
int r1_pin=2;
int r2_pin=3;
int r3_pin=4;
int r4_pin=5;
int r5_pin=6;
float reading=0;
float R=0;
String finalR;
int caseno;

// Dividimos el rango en 5 casos
// caso1: menos de 2850
// caso2: 2850 a 7350
// caso3: 7350 a 28500
// caso4: 28500 a 73500
// caso5: más de 73500
#include <stdlib.h> // necesario para convertir float a string, tiene String(float,n)

void setup() {
  Serial.begin(9600);
}

void loop() {
  // Primero encontramos resistencia desconocida usando 1kOhm
  // Deshabilitamos R2, R3, R4 y R5
  digitalWrite(r2_pin, LOW);
  pinMode(r2_pin, INPUT);
  digitalWrite(r3_pin, LOW);
  pinMode(r3_pin, INPUT);
  digitalWrite(r4_pin, LOW);
  pinMode(r4_pin, INPUT);
  digitalWrite(r5_pin, LOW);
  pinMode(r5_pin, INPUT);
  pinMode(r1_pin, OUTPUT);
  digitalWrite(r1_pin, HIGH);
  
  reading=analogRead(Apin);
  R=(reading*r1)/(1023-reading);
  
  if(R<2850){
    caseno=1;
    if(R<1000){
      finalR = String(R,2) + "Ohm";
    } else {
      R=R/1000;
      finalR = String(R,2) + "kOhm";
    }
  }
  else if(R>=2850 && R<7350){
    caseno=2;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r2_pin, OUTPUT);
    digitalWrite(r2_pin, HIGH);
    reading=analogRead(Apin);
    R=(reading*r2)/(1023-reading)/1000;
    finalR = String(R,2) + "kOhm";
  }
  else if(R>=7350 && R<28500){
    caseno=3;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r3_pin, OUTPUT);
    digitalWrite(r3_pin, HIGH);
    reading=analogRead(Apin);
    R=(reading*r3)/(1023-reading)/1000;
    finalR= String(R,2) + "kOhm";
  }
  else if(R>=28500 && R<73500){
    caseno=4;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r4_pin, OUTPUT);
    digitalWrite(r4_pin, HIGH);
    reading=analogRead(Apin);
    R=(reading*r4)/(1023-reading)/1000;
    finalR = String(R,2) + "kOhm";
  }
  else if(R>=73500){
    caseno=5;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    pinMode(r5_pin, OUTPUT);
    digitalWrite(r5_pin, HIGH);
    reading=analogRead(Apin);
    R=(reading*r5)/(1023-reading)/1000;
    finalR = String(R,2) + "kOhm";
  }
  Serial.println(finalR);
  Serial.println(" ");
  delay(1000);
}

Paso 3: Medidor de capacitancia - Concepto

Código Medidor de Capacitancia

/* RCTiming_capacitance_meter
 * concepto de código tomado de Paul Badger 2008
 * El voltaje del capacitor en una constante de tiempo es 63.2% del voltaje de carga.
 * Un capacitor se llena al 63.2% de su capacidad total en 1 Constante de Tiempo */
int analogPin=0;
int chargePin=7;
int dischargePin=12;
float resistorValue=10000.0; // Usamos resistencia 10kOhm
unsigned long startTime;
unsigned long elapsedTime;
float microFarads;
float nanoFarads;

void setup(){
  pinMode(chargePin, OUTPUT);
  digitalWrite(chargePin, LOW);
  Serial.begin(9600);
}

void loop(){
  digitalWrite(chargePin, HIGH);
  startTime = millis();
  while(analogRead(analogPin) < 648){
    // 647 es 63.2% de 1023, corresponde a voltaje full-scale
  }
  elapsedTime= millis() - startTime;
  microFarads = ((float)elapsedTime / resistorValue) * 1000;
  Serial.print(elapsedTime);
  Serial.print(" mS ");
  if (microFarads > 1){
    Serial.print((long)microFarads);
    Serial.println(" microFarads");
  } else {
    nanoFarads = microFarads * 1000.0;
    Serial.print((long)nanoFarads);
    Serial.println(" nanoFarads");
  }
  // descarga el capacitor
  digitalWrite(chargePin, LOW);
  pinMode(dischargePin, OUTPUT);
  digitalWrite(dischargePin, LOW);
  while(analogRead(analogPin) > 0){
    // espera hasta que el capacitor se descargue completamente
  }
  pinMode(dischargePin, INPUT);
}

Paso 4: Test de Diodo

El pin analógico se pull-up a 5V con resistencia 10k Ohm. Lee 1023 cuando nada está conectado. D12 se pone en OUTPUT, LOW.

Cuando un diodo está polarizado directamente entre pin analógico (5V) y D12 (GND), el pin analógico lee 100-400. En polarización inversa, lee 900-1023. Así podemos encontrar lado p y n de cualquier diodo. Útil para test rápido de LEDs y diodos.

Código Test Diodo

String state = "null";
int checkPin1 = 12;
int checkPin2 = 6;

void setup() {
  Serial.begin(9600);
}

void loop() {
  pinMode(checkPin1, OUTPUT);
  digitalWrite(checkPin1, LOW);
  // analog read normalmente pulled up por 10k resistor, null reading = 1023
  // En polarización directa, pin analógico conectado a checkPin1 (LOW). Lectura < 1023
  // Prácticamente fluye pequeña corriente en inversa, usamos 700 para diferenciar
  if(analogRead(checkPin2)<700){
    state="forward";
  }
  Serial.println(state);
  Serial.println(analogRead(checkPin2));
  state = "null";
  delay(500);
}

Paso 5: Reloj en Tiempo Real (RTC)

El RTC mantiene segundos, minutos, horas, día, fecha, mes y año. Sigue contando aunque se quite alimentación externa gracias a la pila de botón. La fecha a fin de mes se ajusta automáticamente para meses con menos de 31 días, incluyendo correcciones de año bisiesto.

Usaremos 4 pines: Vcc, GND, SDA y SCL. En Arduino Nano/Uno, SDA y SCL son A4 y A5. Para otros Arduino, búscalo.

Usaremos librería "RTClib", que hace configurar y leer la hora súper fácil. Descarga aquí (clic "Download ZIP", extrae "RTClib-master" en carpeta libraries de Arduino).

Para poner hora, descarga "RTC_set_time.ino" adjunto y descomenta:

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

Si quieres usar la hora de tu PC al compilar. O:

rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0)); // año, mes, día, hora, min, seg

Para hora personalizada. Conecta y sube. Abre Monitor Serie a 9600 baudios para ver hora actual. Vuelve a comprobar tras horas para ver cómo RTC mantiene la hora.

¡Importante! Vuelve a comentar esas líneas y sube de nuevo tras poner la hora una vez. ¡Sino la resetearás cada vez que Arduino reinicie!

Código RTC

// Funciones fecha/hora usando DS1307 RTC via I2C y Wire lib
#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 rtc;
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup () {
  Serial.begin(9600);
  rtc.begin();
  // siguiente línea pone RTC a fecha/hora de compilación
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  // Esta línea pone RTC con fecha/hora explícita, ej: 21 Enero 2014 3am
  // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}

void loop () {
  DateTime now = rtc.now();
  Serial.print(now.year());
  Serial.print('/');
  Serial.print(now.month());
  Serial.print('/');
  Serial.print(now.day());
  Serial.print(" (");
  Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
  Serial.print(") ");
  Serial.print(now.hour());
  Serial.print(':');
  Serial.print(now.minute());
  Serial.print(':');
  Serial.print(now.second());
  Serial.println();
  Serial.println();
  delay(1000);
}

Paso 6: Configuración Final

Ese es el circuito final combinando todos los elementos. El código principal y archivo Fritzing están al final.

Descarga Fritzing de fritzing.org si no lo tienes.

Extrae Main_code.rar y abre Main_file_rtc.ino. Incluí declaraciones de variables en header definations.h, se añade automáticamente al abrir el código principal.

Las partes están en funciones: Clock(), findResistance(), findCapcitance() y diodeTest(). Están en pestañas separadas, facilitando lectura y cambios. El archivo principal solo verifica estado del "botón modo" y llama funciones apropiadas.

Otros detalles están explicados en el código.

Tras prueba en protoboard, ¡listos para hacer el IC!

Nota: Zumbador si no se usa aún, puede usarse cuando sea necesario, ej. función continuidad.

Paso 7: Preparando los interruptores

Toma los 3 interruptores deslizantes con 3 pares de cable ~10cm. Yo dividí cable plano para esto.

Pela pequeña parte aislamiento (no más 5mm) y tuerce hilos. Aplica estaño a 2 pines adyacentes de cada interruptor. Sujétalo mientras sueldas, usé alicate pesado.

Si no has soldado antes, ahora es buen momento. YouTube tiene muchos videos. Lecciones de PACE muy informativas.

Estaña los cables: toca punta soldador al cable, aplica poco estaño entre punta y cable (crea puente calor), luego aplica estaño directamente al cable, lado opuesto a punta. Quita estaño, quita punta.

Sujeta interruptor, lleva cable estañado al pin y refunde estaño tocando soldador. Repite con segundo cable. Puse cables oscuros en un lado de interruptores.

Repite con un pulsador (será botón reset). Asegúrate de no poner cables en bornes normalmente conectados del botón.

Paso 8: Haciendo la carcasa - Cortando el layout

Descarga "Layout_Final_A3.pdf" o "Layout_Final_ANSI_B.pdf" según tamaño papel de tu región (al final).

Imprime en A3 (29.7 x 42.0cm o 11.69 x 16.53 pulg) o ANSI B (11 x 17 pulg / 279 × 432mm). Selecciona tamaño papel correcto, orientación, y opción "Tamaño real". Verifica midiendo ángulo recto esquina inferior derecha: debe ser 2cm x 2cm.

Corta cartón un poco mayor que layout. Haz rollos cinta doble cara, pégalos en lugares indicados. Pega hoja en cartón.

Usa tijeras afiladas o cúter con regla para cortar contorno exterior. Cúter mejor que tijeras. La mayoría tienen hojas que se rompen por tramos para punta fresca/afilada. Pon otro cartón o madera debajo para cortes limpios.

No poner regla mal sobre la línea al cortar es error común. No lo hagas con prisa.

Paso 9: Carcasa - Marcado y plegado

Con cúter y regla, marca cuidadosamente todas las líneas de plegado, excepto la línea central en área LCD. Dobla y pliega todas las partes plegables y corrige marcados incompletos.

Para base (mitad inferior):

Lija primeros 4 bordes en ángulo, aplica pegamento caliente (un lado cada vez), une y sujeta 30-60 seg mientras enfría.

Haz dos agujeros con chincheta como se muestra y agrándalos con lápiz para que entre tornillo. Aprieta tuerca por dentro, aplica pegamento caliente (solo en tuerca), deja enfriar. Quita tornillo con destornillador.

Doblas dos solapas laterales hacia dentro y pégalas. Parte exterior ligeramente inclinada y parte central plana.

Paso 10: Carcasa - Añadiendo interruptores

Toma 3 interruptores deslizantes con cables soldados, mide rectángulo necesario. Márcalo en lado izquierdo de caja (visto desde fuera). Córtalo con cúter, lija un poco por dentro para quitar material sobrante.

Pon primer interruptor en posición, sujétalo y pon pegamento en un lado. Deja enfriar. Repite con otros dos, luego pega lados restantes. Nota: Los pines con cables de los interruptores deben estar en el mismo lado.

Haz otro agujero en otro lado para pulsador reset. Sujeta botón y pega. Dobla solapa inferior hacia dentro y pega.

Paso 11: Carcasa - Tapa superior

Lija bordes y pega solapas laterales hacia dentro (igual que base) para la tapa.

Paso 12: Carcasa - Añadiendo LCD

Marca línea central (no antes por ser delicada y aflojarse).

Dobla tapa sobre base y verifica que todo encaje, espacio suficiente para patillas IC. (Ver foto)

Recorta solapas cubiertas como en imágenes.

Centra LCD en área LCD, márcalo con lápiz. Con regla haz rectángulo bien y córtalo con cúter. Dobla ventana LCD y pega bisagras para mantener posición. Inserta LCD y modifica si hace falta.

Finalmente, pega 4 esquinas LCD (sin exceso) y colócalo en posición.

Paso 13: Carcasa - Solapas finales

Lija, recorta y cierra solapa triangular.

Haz pieza pequeña como se muestra y pégala a la tapa. Haz dos agujeros, ensánchalos con lápiz para insertar tornillo y cerrar tapa a base.

Paso 14: Placa de circuito - Ajuste

Corta PCB de propósito general al tamaño correcto para que encaje en la caja. La mía 2x4 pulgadas. Para cortar, usa regla y cúter y pasa varias veces ambos lados y se rompe fácil.

Colócala dentro. Si pegamento de solapa levanta PCB, recalienta pegamento para aplanar o reduce PCB un poco.

Recorta parte pequeña para que 3 interruptores encajen y PCB entre del todo.

Paso 15: Placa - Arduino Nano

Corta conectores hembra del tamaño correcto para Arduino.

Colócalo en borde central de PCB y suelda todos los pines.

Paso 16: Placa - Ohmímetro

Antes de hacer conexiones en PCB, verifica doblemente desde diseño final del circuito.

Para ohmímetro, empieza añadiendo resistencia 1k Ohm a pin D2 de Arduino. Coloca Arduino y marca pin cuidadosamente. En reverso, dobla como se muestra y suelda.

Haz lo mismo con otras 4 resistencias: 4.7k, 10k, 47k y 100k Ohm.

Nota: Mantener todas las bandas de tolerancia (banda dorada) en un lado es buena práctica, ej. ARRIBA y DERECHA.

Une segundos extremos de resistencias y suelda a A7.

Paso 17: Placa - Medidor capacitancia y test diodo

Medidor Capacitancia:

Suela resistencia 220 Ohm de D12 a A0. Y 10k Ohm de A0 a D7.

Nota: D7 (pin digital) también se usa para pin datos LCD D4.

Test Diodo:

Suela resistencia pullup 10k Ohm de A6 a +5V.

Paso 18: Conectores para LCD

Solo usamos primeros 6 y últimos 6 pines del LCD. Pines D0-D3 sin usar. Haremos conectores solo para pines usados. Recomendado hacer lo mismo porque enchufar/desenchufar conector 16 pines es muy difícil una vez montado.

Corta 2x 6 pines hembra y macho. Toma cable plano 6 hilos, ~2-2.5 pulgadas.

Pela aislamiento y estaña extremos. Estaña también pines conectores. Únelos uno a uno como interruptores deslizantes.

Aplica pegamento caliente para asegurar cables.

Paso 19: Placa - Conexiones LCD

Coloca PCB en caja. Enchufa conector a LCD y ve dónde debe ir puerto hembra en PCB, suéldalo.

Deja 4-5 filas de puntos detrás del puerto LCD. El interruptor de encendido se añadirá aquí después.

Mide longitud hilo unifilar para conectar pines datos (D4, D5, D6, D7) del LCD a pines digitales (D7, D8, D9, D10) del Arduino, respectivamente.

Añade potenciómetro 10k ohm: extremos laterales a Vcc, GND y pin central a V0.

Conecta Vss(GND) LCD a GND, Vdd a +5V. También R/W a GND.

Pin Arduino	LCD
D7	D4
D8	D5
D9	D6
D10	D7
GND	Vss(GND)
+5V	Vdd

Paso 20: Placa - Módulo RTC

Desoldé pines header 90° del módulo y puse rectos para que quede plano en PCB.

Suela header hembra 4 pines y conecta a Vcc, GND, SDA a A4 y SCL a A5.

Paso 21: Carcasa - Botón modo

Marca círculo ~1cm diámetro en esquina pin1 de carcasa IC. Marca centro con chincheta, agranda con lápiz. Usa herramienta adecuada para aumentar diámetro a 1cm. Lija por dentro y pega con pegamento caliente.

Corta pieza PCB (10-11) puntos x 5 puntos. Enchufa y suelda pulsador, resistencias 220 y 10k Ohm como se muestra.

Toma cable plano 3 hilos ~15cm. Estaña extremos y suelda como se muestra. Anota qué color va dónde, útil luego.

Corta 2 trozos pequeños goma de borrar y ponlos en extremos de la placa. Altura de goma tal que botón quede por debajo nivel interior cartón visto desde fuera. Usé 4mm.

Fija con pegamento caliente como se muestra.

Paso 22: Carcasa - Puntos de test

Corta 6x conectores hembra 6 pines. Lija lados para suavizar.

Marca posiciones y corta ranuras para headers. Inserta en sitio y pega por dentro.

Aplica poca estaño a todos los pines y usa jumper pelado para unirlos todos. Asegúrate que todos conectados. No sigas calentando para perfeccionar. Calentar un pin calienta los vecinos.

Toma cable plano 6 hilos, estaña y conéctalo a cada ranura. Puse colores oscuros en lado negativo. Pega con pegamento caliente para fijar.

Paso 23: Las patas

Descarga "Legs_A4.pdf" o "Legs_ANSI_A.pdf" según tamaño papel (al final).

Imprime en A4 (21 x 29.7cm / 8.27 x 11.69 pulg) o ANSI A (8.5 x 11 pulg / 21.6 × 27.9cm). Selecciona tamaño papel correcto, orientación, "Tamaño real". Verifica midiendo rectángulo: debe ser 8.4 x 11.8cm.

Corta, marca y pega igual que carcasa principal, ver imágenes.

Paso 24: ¡Dándole brillo!

Corta papel alu 1x2 pulgadas y pégalo con cuidado, pliegue a pliegue, en extremos patas con pegamento metal-cartón. Usé Fevibond.

Pega parche cubriendo todas las cimas patas (como se muestra), haz cortes lentos con cúter. Cuidado. El alu tiende a rasgarse lateralmente. Usa algo plano para pegar alu entre patas y dar buen acabado.

Cubre con cinta adhesiva transparente, igual que alu, para proteger de objetos afilados.

Paso 25: Interruptor de encendido

Mide y corta pata interruptor colocándolo bien. Pega temporalmente otros pines con cinta para posición pin1 correcta.

Mezcla bien m-seal (masilla epoxi, endurece mucho al secar). Pon como en imágenes y usa polvo+superficie plana para moldear. Deja secar.

Rellena también huecos en carcasa.

No usamos pegamento caliente aquí porque es gomoso y el interruptor necesita material fuerte y frágil.

Paso 26: Interruptor encendido a PCB

Tras secar m-seal, coloca y verifica todo bien.

Corta 3 pines hembra y macho, colócalos en PCB alineados con pines interruptor. Suelda parte hembra.

Estaña patas interruptor y pines macho header, únelos. Verifica encaje correcto.

Prueba pulsar interruptor on/off poniendo dedo detrás para soporte. Añadiremos varilla soporte después.

Conecta pin lateral header hembra (interruptor) a Vin. Me di cuenta tarde y tuve muchos problemas.

Fija header con pegamento caliente.

Paso 27: Puerto USB

Coloca PCB bien (con Arduino) y corta rectángulo para puerto mini USB.

Quita algo de plástico del cable USB para que encaje en Arduino. Prueba conexión correcta.

Paso 28: Otras cosas...

Quité todos los LEDs del Arduino Nano y también LED encendido de mi módulo RTC. Consumen energía innecesaria, importa si usas pilas.

Lija m-seal seco para que mezcle suavemente con cartón. Limpia polvo con servilleta húmeda antes de pintar.

Añadí zumbador para algunas funciones. ¡Zumbadores sensibles, no uses mucho calor soldando!

Paso 29: ¡Hora de pintar!

No uses pintura espesa directa, aparecen marcas pincel. Usa suficiente agua.

Asegura que no se formen microburbujas. Se forman al dar golpecitos con pincel.

No pintes bisagra tapa, la pintura la bloquearía.

Esta es capa base. Otra capa se añadirá al terminar.

Paso 30: Soldando todos los cables

Consulta diseño circuito antes de hacer conexiones.

Primero conecta pulsador reset: un extremo a RST y otro a GND.

Luego, interruptor retroiluminación: un extremo a +5V y otro a 'A' (ánodo) LED retroiluminación. También 'K' (cátodo) a GND.

Interruptor RS: un extremo a RS y otro a pin D1 (TX).

Interruptor Enable: un extremo a 'E' (Enable) y otro a pin D0 (RX).

Interruptor	Conexión
Reset - pulsador	RST y GND
Retroiluminación - deslizante	+5V y A
RS - deslizante	D1 (TX) y RS
Enable - deslizante	D0 (RX) y E

Nota: Pines D0 y D1 conectados mediante interruptores porque mantenerlos conectados a veces causa problemas al usar Serial (para depurar).

Esto completa cableado base. Pega con pegamento caliente tras verificar conexiones.

Conecta 3 cables botón cambio modo: resistencia 10k pull-down a GND. Resistencia 220 Ohm a pin D11 y pin entrada a +5V o VCC.

Finalmente conecta 6 cables ranuras test a sus sitios apropiados (ver imágenes).

Positivo	Negativo
Test Resistencia	A7	GND
Test Capacitancia	A0	GND
Test Diodo	A6	D12

Nota: Todos los +5V y GND son iguales, conecta al sitio más cómodo.

Paso 31: Añadiendo portapilas

Coloca portapilas en tapa superior, haz cortes para que quepa dentro y tapa cierre bien.

Suela cables a portapilas, pela y estaña. Suelda positivo a pin central interruptor encendido y negativo a tierra.

Pega PCB a base tras todas conexiones.

Enrolla cables y colócalos. Inserta pilas (portapilas se expande un poco) y pega portapilas a tapa.

Paso 32: Añadiendo las patas

Corta parte interior patas para que encaje. Pégalo en sitio.

Mete pin interruptor encendido para ver si encaja perfecto. Saca, añade varilla metal, trozo madera o algo fuerte longitud adecuada que evite interruptor se mueva atrás. Pega en sitio.

Prueba interruptor, debe girar on/off suavemente.

Enciende IC y prueba todas funciones. Si no funciona ve a solución problemas.

Paso 33: Acabado final

Usa M-seal (o equivalente) para rellenar pequeños huecos zona test y botón modo. Tras secar, lija bien y aplica segunda capa pintura.

Haz botón con trozo cartón, pinta negro y cubre con cinta (da acabado brillante). Aplica gota mínima pegamento y pega botón en sitio.

Paso 34: Problemas y solución

Haz todo correctamente. Es la parte más aburrida de cualquier proyecto y no quieres llegar aquí solo porque soldaste pines mal!

• Revisa cada junta soldada y asegura que no toca adyacente. Usa test continuidad multímetro.
• Tras cortar patas componentes/jumpers, asegura que pata cortada no caiga debajo PCB. Puede causar cortocircuitos.
• Apunta lo que necesites recordar en cuaderno, no confíes en memoria.
• Si LCD no muestra, verifica contraste ajustado. También que interruptores pin0 y 1 estén ON. Verifica todas conexiones pin LCD-Arduino con test continuidad. Usa jumpers protoboard donde multímetro no llega.
• Sube programa "hello world" LCD para ver si problema es código.
• Si función concreta no funciona, verifica sus conexiones y compara con código.
• Y lo más importante, ¡mantén tus curiosas mascotas con sus mentes malvadas lejos de tu espacio de trabajo! :p

Paso 35: Cosas que hice, errores que cometí

Mientras testaba circuitos y tenía idea aproximada de qué quería hacer, decidí diseño IC. Medí ICs reales, tomé ratios longitudes, calculé ángulo con trigonometría ~80 grados. Decidí longitud/ancho caja interior y construí sobre eso (ver imagen). Una vez layout planeado, empecé a dibujarlo con precisión en papel grande. Tras lucha dibujando líneas precisas, me di cuenta que esto debe hacerse en ordenador. Aprendí CAD básico e hice layout en él. :) Pero ese layout no funcionó y tuve que rehacer todo corte y carcasa. (Ver imágenes)

Al quitar LEDs Arduino Nano usé presión excesiva quitando LED rebelde, y arranqué una pista PCB. Siempre desuelda sin forzar/aplicar presión en juntas, las pistas son delicadas y salen fácil si no mantienes calma.

Cuando todas juntas soldadas y proyecto a punto de terminar, por emoción y ansias, pegué PCB dentro de caja antes de añadir portapilas. Tuve que re-fundir pegamento caliente con soldador (cuidado no fundir aislamiento cables) y sacar PCB para soldar cables portapilas. El soldador se limpia después.

Pila módulo RTC estorbaba pilas al cerrar, así que separé portapilas (¡Advertencia: desuelda solo con pila quitada!) y puse cables extensión para colocar pila en lados donde hay espacio.

Todos los PDFs layout, archivos CAD y código principal pueden descargarse aquí: Google Drive

Código

El código completo está disponible en el repositorio del proyecto. Incluye los cuatro snippets principales (ohmímetro, medidor capacitancia, test diodo, RTC) y el código principal integrado con todas las funciones modularizadas.

Esquemáticos

Main_Schematic.fzz