Hola a todos, si andan por aquí de seguro ya has usado o por lo menos visto un Arduino, ESP8266 o algun otro microcontrolador. También de seguro ya te habrás preguntado, cómo fabricar una PCB , placa o tarjeta electrónica, llena de cosas que nos gustan mucho y nos son indispensables a la hora de crear nuestro proyectos Maker.
Incluso tal vez ya seas un experto y necesites que tu proyecto incluya algún sensor o componente que tu placa de desarrollo no lo tiene. Ha llegado el momento de aprender cómo fabricar una PCB. Sin embargo, existe un mundo de información en la web de cómo hacerlas, pero debemos empezar por el principio.
Lo primero es usar la protoboard (Bredboard) correctamente, para ensamblar tu prototipo y comprobar que este funcione correctamente. Enseguida es pasar ese prototipo a una tarjeta pre-perforada o multipropósito, donde deberás insertar los diversos componentes (resistencias, condensadores, IC, etc), cablearlos y soldarlos. Esto te permitirá ver el desempeño de tu circuito de la forma mas cercana a una PCB de producción profesional.
Resumiendo en este articulo aprenderás:
- Usar la protoboard
- Componentes básicos usados en los circuitos electrónicos
- Leer esquemáticos
- Armar circuitos en protoboard
- Armar circuitos en placa fenolicas pre-perforadas o multiproposito
- Soldar componentes
Indice de contenidos
Quién es Gustavo Reynaga
No siempre es fácil hablar de uno mismo, así que te «platicare» quien soy como si estuviéramos departiendo en algún café o Pub. Nací en la Ciudad y puerto de Mazatlán, Sinaloa, México. Mis estudios profesionales son de Contador Publico y tengo una Maestría en Educación.
Trabajo como Instructor de Informática desde 1996 en un Centro de Capacitación para el Trabajo. En el receso de Semana Santa de 2015 aproveché a buscar algo que pudiera innovar la especialidad que imparto y descubrí de Arduino y Raspberry Pi.
Compré ambos y empece a jugar con ellos, descubrí que Arduino estaba mucho mas documentado y era mas económico por lo que decidí profundizar en él y compré un kit de desarrollo y desde entonces estoy comprometido con la cultura Maker. No te quiero aburrir, te invito a escuchar el podcast hecho por Programarfacil donde platico mas sobre quien soy y que estoy haciendo.
Puedes ver mis trabajos en los siguientes enlaces.
- Github . Si quieres profundizar en el funcionamiento de GitHub entra aquí.
- Oshwi
- HacksterIO
Material para fabricar una PCB desde cero
Lo primero es ver el material que vamos a utilizar a lo largo de este artículo. Aquí te dejo todo lo necesario para seguir este tutorial. Aunque algún componente no lo tengas no esperes a ponerte en acción.
Coge cualquier otro similar o con prestaciones superiores o inferiores. Hay que ponerse en acción esta es la única manera de llevar a buen puerto tu proyecto.
- 1 Protoboard (De 400 o 800 puntos)
- 3 Led 5mm (Color indistinto)
- 1 Batería de 9v
- 1 Broche para bateria de 9v
- 3 Potenciometro de 100k (deben ser del mismo valor los 3)
- 1 led RGB
- 5 Resistencias de 470 ohms
- 5 Resistencias de 1 K
- 1 Placa PCB perforada de 5*9 (De preferencia con agujeros individuales y de doble cara)
- 1 Cautin (soldador) de 40w
- 1 Soldadura con alma de resina
- 1 Tira de pines con 40
- Cables (varios)
Cómo fabricar una PCB: armado del prototipo
Vamos a comenzar con el prototipo mínimo viable. Esto nos permitirá dos cosas muy importantes. Lo primero es coger experiencia con algunos de los componentes y herramientas. Lo segundo es conseguir algo funcional lo más rápido y económico posible.
No te olvides que estás aprendiendo y por eso es importante conseguir resultados lo antes posible. Da lo mismo si no funciona todo correctamente, esa no es la meta. La meta es avanzar y aprender haciendo.
Vamos a comenzar por lo más básico, el uso de la protoboard.
Uso de la protoboard
La protoboard es una placa que a simple vista se le ven muchas perforaciones, en las cuales se le insertan las terminales (patitas) de los componentes electrónicos. Pero ojo, debemos tener el cuidado necesario de donde colocamos las cosas, ya que en su interior, esta placa cuenta con vias (carreteras) que conectan unos agujeros con otros.
Si quieres aprender mas puedes ver el vídeo de Enrique en Rincón Ingenieril.
Lectura de esquemático (Diagrama electrónico)
Un esquemático, es un mapa que muestra con símbolos y lineas los componentes electrónicos y sus conexiones en el circuito. Es importante saber interpretarlos ya que con esto podemos utilizar la enorme cantidad de circuitos que se pueden encontrar por Internet.
Es un paso fundamental a la hora de aprender cómo fabricar una PCB desde cero.
A continuación se muestra un diagrama esquemático de un circuito con el famoso 555, seguido de su representación gráfica y una muestra de los símbolos de componentes electrónicos.
Fuente 555 timer circuits
Este esquema eléctrico se traduciría a este circuito eléctrico.
Y ahora te preguntarás ¿cómo se que significan todos esos símbolos? Bueno pues aquí te dejo un pequeño resumen de lo que es cada componente.
Fuente Slideplayer de Lorena Rivas Montoya
Si deseas aprender más sobre cómo leer y entender esquemas eléctricos, no te pierdas el vídeo de Alex en Tutoelectro.
Componentes Through Hole y SMD
Existen dos tipos de componentes que se pueden montar en placas PCB, los True hole y SMD.
True Hole: Son todos los componentes electrónicos, pasivos o activos que tienen «patitas» y que se sueldan a las placas usando los agujeros que previamente se hincieron para tal fin.
SMD: Son componentes pasivos o activos que se sueldan a las placas usando unas almohadillas (pads) que previamente se fabricaron, este tipo de componentes son los mas utilizados hoy en día.
Colocando componentes
A continuación haremos unos ejercicios prácticos que te permitirán reafirmar los conceptos anteriores.
Ejercicio 1 Encender un Led Hola Mundo
Vamos a armar nuestro primer circuito, el cual esta compuesto por una resistencia de 470 ohms, un Led (cualquier color) y la batería de 9v. Empezamos por el diagrama esquemático del circuito, el cual está compuesto de 3 elementos mencionados anteriormente, es fácil ubicar cada uno de ellos.
El Led y la batería tienen polaridad, esto es, que cuentan con polos Positivo o Ánodo (+) y Negativo o Cátodo (-). Es importante tener bien ubicados ambos polos, para evitar un corto circuito. En la batería están identificados por los símbolos (+) para el positivo y el (-) para el negativo.
Para el Led, La Pata (Terminal) mas larga es la positiva y la mas corta es la negativa. la resistencia no tiene polaridad, por lo que puedes colocarla indistintamente.
Si traducimos este esquema eléctrico a un circuito eléctrico obtenemos lo siguiente. El circuito puede variar dependiendo de qué protoboard tengas y de cómo conectes los componentes.
Guíate con la imagen para colocar cada uno de los componentes, insertando la patita (terminal) en el agujero de la Breadboard o protoboard. Empieza por el Led, luego la resistencia, dejando la batería al ultimo.
Si todo se conecto correctamente el led encenderá. Como extra cambia la resistencia de 470 ohmios por una de 1k, observa la diferencia. Ahora te estarás preguntando ¿por qué pasa esto? Te invito a que veas este entretenido vídeo de Charlie Labs, seguro que te ayuda a entenderlo.
Ejercicio 2 Encender un Led RGB y crear combinaciones de colores usando el potenciometro.
Este ejercicio es muy divertido además de didáctico. Usarás un LED RGB que en su interior contiene en realidad 3 Leds: R=red (rojo), G=green (verde) y B=blue (azul).
Una vez armado el circuito podrás crear combinaciones de colores cambiando la intensidad del LED mediante los potenciómetros. Antes de continuar te comento que existen dos tipos: con Anodo/Positivo(+) común o Catodo/Negativo(-) común.
Al igual que los LEDs comunes, sera la patita mas larga la que tenga esta función. Como abras adivinado, el armado para cada tipo de LED será diferente, no te preocupes, primeramente te explicare como descubrir cual tienes, observa la siguiente figura.
Fuente Teslaben
Haz el siguiente circuito usando como guía la pata mas larga a la que le conectarás el cable Positivo. Enseguida selecciona cualquier de las tres restantes. Coloca una resistencia de 470 ohmios y a esa resistencia conecta el cable negativo.
Esto te permitirá saber qué tipo de LED RGB tienes. Si enciende tu LED es ánodo común.
Si no enciende invierte los cables como se muestra en la figura para comprobar que es cátodo común.
Una vez identificado tu tipo de LED RGB, procederemos a armar nuestro circuito en el siguiente orden:
- Led
- Resistencias
- Potenciometros
- Batería
Dependiendo del tipo de LED RGB que tengas, sigue las siguientes imágenes para armar el circuito.
Ánodo común
Cátodo común
Una vez que los 3 LEDs enciendan gira los 3 potenciómetros en sentido horario hasta su tope, y después en sentido contrario.
Por último quiero comentarte una herramienta bastante interesante. Tinkercad ofrece una herramienta en linea donde puedes armar y simular tus circuitos, la cual considero muy útil para practicar lo aprendido sin freír tus circuitos :).
Para usarlo puedes acceder al vídeo de Oscar Bellón.
Cómo fabricar una PCB: trabajando con tarjetas pre-perforadas
A llegado el momento de culminar nuestros esfuerzos y hacer nuestras PCBs. Te comento que las haremos de manera que se puedan utilizar con la placa Arduino UNO o cualquier otro microcontrolador.
Vas a necesitar una placa pre-perforada. El precio es bastante económico y merece la pena tener bastantes en casa.
En este paso será necesario el uso del cautin (soldador). Si nunca has soldado o tienes poca experiencia te recomiendo ver el vídeo de MakerLab.
#1 LED Hola Mundo
Para que nuestra PCB tenga el tamaño adecuado sera necesario que montemos provisionalmente los componentes sobre la tarjeta perforada, de manera que podamos marcar para después cortar con un cúter (navaja) la parte que usaremos, para posteriormente soldar.
Ahora con la ayuda de un manos libres (no indispensable) colocaremos el primer componente (LED, Resistencia, etc.) y doblaremos un poco las patitas hacia fuera, con la intención de que se pueda sostener al colocarlo boca abajo. Enseguida agregaremos un punto de soldadura a la primer patita y después a la segunda
Repite el proceso con los demás componentes, recuerda, deben estar unidos respetando su polaridad.
Yo use el siguiente orden, LED, resistencia, pines y cables.
Para los cables use un pedazo de cable de red, el cual pelé para sacar los 4 pares. Enseguida con un desarmador (destornillador) peine cada par trenzado haciendo presión con mi dedo sobre el cable hasta que queden «lisos«.
En la siguiente secuencia de imágenes te muestro el proceso.
Enseguida corte a la medida necesaria y despunte para dejar visible el cable de cobre para soldarlo. Recomiendo usar una pinza de electricista en buen estado, ya que si no tiene filo el pelacable, te dará mas trabajo, o incluso podrás dejar «mordido» el cable y este se romperá con facilidad al manipularlo.
Ahora probaremos nuestro flamante PCB recién hecha en nuestro Arduino, conectamos El positivo a un pin digital y el negativo a GND. para este ejemplo usare el Pin #5
Escribiremos el siguiente código
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
/* Blink Turns on an LED on for one second, then off for one second, repeatedly. This example code is in the public domain. Modify by @gsreynaga for programarfacil.com */ // Pin 13 has an LED connected on most Arduino boards. // give it a name: int led = 5; // the setup routine runs once when you press reset: void setup() { // initialize the digital pin as an output. pinMode(led, OUTPUT); } // the loop routine runs over and over again forever: void loop() { digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) delay(500); // wait for a second digitalWrite(led, LOW); // turn the LED off by making the voltage LOW delay(500); // wait for a second } |
Compilamos y subimos.
Si el Led de la PCB parpadea ¡¡¡ bien hecho !!! En caso contrario debemos revisar conexiones y soldaduras para identificar el problema. Te invito a que hagas otras 2 PCBs y si es posible con LEDs de diferente color.
#2 LED RGB
Vamos a fabricar una PCB para nuestro LED RGB. Aplicaremos el mismo procedimiento que hicimos anteriormente: colocamos los componentes, marcamos, quitamos los componentes, recortamos lo necesario y empezamos a soldar.
Comenzamos con el LED teniendo el cuidado de dejar marcado la patita de funge como ánodo o cátodo común. Luego seguimos con los pines, cable y resistencias. Para evitar el usar mucho cableado he decido alargar las patitas de las resistencias de manera que queden contiguas tanto al LED RGB como a los pines y usar la soldadura como «puente«.
Una vez soldados todos los componentes, montamos nuestro circuito, cableando en el siguiente orden:
Led RGB Arduino UNO
Rojo (R) 11
Comun GND o 5V (Dependerá del tipo de Led que tengas)
Verde (G) 10
Azul (B) 9
Nota, puedes usar cualquier otro orden o numero de pin, solo asegúrate que estos sean PWM, no esta por demás decirte que si haces cambios, también deberás hacer cambios al programa.
Para probar nuestra PCB debemos cargar el siguiente programa.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 |
/* SparkFun Inventor's Kit Example sketch 03 RGB LED Make an RGB LED display a rainbow of colors! Hardware connections: An RGB LED is actually three LEDs (red, green, and blue) in one package. When you run them at different brightnesses, the red, green and blue mix to form new colors. Starting at the flattened edge of the flange on the LED, the pins are ordered RED, COMMON, GREEN, BLUE. Connect RED to a 330 ohm resistor. Connect the other end of the resistor to Arduino digital pin 9. Connect COMMON pin to GND. Connect GREEN to a 330 ohm resistor. Connect the other end of the resistor to Arduino digital pin 10. Connect BLUE to a 330 ohm resistor. Connect the other end of the resistor to Arduino digital pin 11. This sketch was written by SparkFun Electronics, with lots of help from the Arduino community. Visit http://learn.sparkfun.com/products/2 for SIK information. Visit http://www.arduino.cc to learn about the Arduino. Version 2.0 6/2012 MDG */ // First we'll define the pins by name to make the sketch // easier to follow. // Here's a new trick: putting the word "const" in front of a // variable indicates that this is a "constant" value that will // never change. (You don't have to do this, but if you do, the // Arduino will give you a friendly warning if you accidentally // try to change the value, so it's considered good form.) const int RED_PIN = 11; const int GREEN_PIN = 10; const int BLUE_PIN = 9; // This variable controls how fast we loop through the colors. // (Try changing this to make the fading faster or slower.) int DISPLAY_TIME = 10; // In milliseconds void setup() { // Here we'll configure the Arduino pins we're using to // drive the LED to be outputs: pinMode(RED_PIN, OUTPUT); pinMode(GREEN_PIN, OUTPUT); pinMode(BLUE_PIN, OUTPUT); } void loop() { // In this sketch, we'll start writing our own functions. // This makes the sketch easier to follow by dividing up // the sketch into sections, and not having everything in // setup() or loop(). // We'll show you two ways to run the RGB LED. // The first way is to turn the individual LEDs (red, blue, // and green) on and off in various combinations. This gives you // a total of eight colors (if you count "black" as a color). // We've written a function called mainColors() that steps // through all eight of these colors. We're only "calling" the // function here (telling it to run). The actual function code // is further down in the sketch. mainColors(); // The above function turns the individual LEDs full-on and // full-off. If you want to generate more than eight colors, // you can do so by varying the brightness of the individual // LEDs between full-on and full-off. // The analogWrite() function lets us do this. This function // lets you dim a LED from full-off to full-on over 255 steps. // We've written a function called showSpectrum() that smoothly // steps through all the colors. Again we're just calling it // here; the actual code is further down in this sketch. showSpectrum(); } // Here's the mainColors() function we've written. // This function displays the eight "main" colors that the RGB LED // can produce. If you'd like to use one of these colors in your // own sketch, you cancopy and paste that section into your code. void mainColors() { // Off (all LEDs off): digitalWrite(RED_PIN, LOW); digitalWrite(GREEN_PIN, LOW); digitalWrite(BLUE_PIN, LOW); delay(1000); // Red (turn just the red LED on): digitalWrite(RED_PIN, HIGH); digitalWrite(GREEN_PIN, LOW); digitalWrite(BLUE_PIN, LOW); delay(1000); // Green (turn just the green LED on): digitalWrite(RED_PIN, LOW); digitalWrite(GREEN_PIN, HIGH); digitalWrite(BLUE_PIN, LOW); delay(1000); // Blue (turn just the blue LED on): digitalWrite(RED_PIN, LOW); digitalWrite(GREEN_PIN, LOW); digitalWrite(BLUE_PIN, HIGH); delay(1000); // Yellow (turn red and green on): digitalWrite(RED_PIN, HIGH); digitalWrite(GREEN_PIN, HIGH); digitalWrite(BLUE_PIN, LOW); delay(1000); // Cyan (turn green and blue on): digitalWrite(RED_PIN, LOW); digitalWrite(GREEN_PIN, HIGH); digitalWrite(BLUE_PIN, HIGH); delay(1000); // Purple (turn red and blue on): digitalWrite(RED_PIN, HIGH); digitalWrite(GREEN_PIN, LOW); digitalWrite(BLUE_PIN, HIGH); delay(1000); // White (turn all the LEDs on): digitalWrite(RED_PIN, HIGH); digitalWrite(GREEN_PIN, HIGH); digitalWrite(BLUE_PIN, HIGH); delay(1000); } // Below are two more functions we've written, // showSpectrum() and showRGB(). // showRGB() displays a single color on the RGB LED. // You call showRGB() with the number of a color you want // to display. // showSpectrum() steps through all the colors of the RGB LED, // displaying a rainbow. showSpectrum() actually calls showRGB() // over and over to do this. // We'll often break tasks down into individual functions like // this, which makes your sketches easier to follow, and once // you have a handy function, you can reuse it in your other // programs. // showSpectrum() // This function steps through all the colors of the RGB LED. // It does this by stepping a variable from 0 to 768 (the total // number of colors), and repeatedly calling showRGB() to display // the individual colors. // In this function, we're using a "for() loop" to step a variable // from one value to another, and perform a set of instructions // for each step. For() loops are a very handy way to get numbers // to count up or down. // Every for() loop has three statements separated by semicolons: // 1. Something to do before starting // 2. A test to perform; as long as it's true, // it will keep looping // 3. Something to do after each loop (usually // increase a variable) // For the for() loop below, these are the three statements: // 1. x = 0; Before starting, make x = 0. // 2. x < 768; While x is less than 768, run the // following code. // 3. x++ Putting "++" after a variable means // "add one to it". (You can also use "x = x + 1") // Every time you go through the loop, the statements following // the loop (those within the brackets) will run. // And when the test in statement 2 is finally false, the sketch // will continue. void showSpectrum() { int x; // define an integer variable called "x" // Now we'll use a for() loop to make x count from 0 to 767 // (Note that there's no semicolon after this line! // That's because the for() loop will repeat the next // "statement", which in this case is everything within // the following brackets {} ) for (x = 0; x < 768; x++) // Each time we loop (with a new value of x), do the following: { showRGB(x); // Call RGBspectrum() with our new x delay(DISPLAY_TIME); // Delay for 10 ms (1/100th of a second) } } // showRGB() // This function translates a number between 0 and 767 into a // specific color on the RGB LED. If you have this number count // through the whole range (0 to 767), the LED will smoothly // change color through the entire spectrum. // The "base" numbers are: // 0 = pure red // 255 = pure green // 511 = pure blue // 767 = pure red (again) // Numbers between the above colors will create blends. For // example, 640 is midway between 512 (pure blue) and 767 // (pure red). It will give you a 50/50 mix of blue and red, // resulting in purple. // If you count up from 0 to 767 and pass that number to this // function, the LED will smoothly fade between all the colors. // (Because it starts and ends on pure red, you can start over // at 0 without any break in the spectrum). void showRGB(int color) { int redIntensity; int greenIntensity; int blueIntensity; // Here we'll use an "if / else" statement to determine which // of the three (R,G,B) zones x falls into. Each of these zones // spans 255 because analogWrite() wants a number from 0 to 255. // In each of these zones, we'll calculate the brightness // for each of the red, green, and blue LEDs within the RGB LED. if (color <= 255) // zone 1 { redIntensity = 255 - color; // red goes from on to off greenIntensity = color; // green goes from off to on blueIntensity = 0; // blue is always off } else if (color <= 511) // zone 2 { redIntensity = 0; // red is always off greenIntensity = 255 - (color - 256); // green on to off blueIntensity = (color - 256); // blue off to on } else // color >= 512 // zone 3 { redIntensity = (color - 512); // red off to on greenIntensity = 0; // green is always off blueIntensity = 255 - (color - 512); // blue on to off } // Now that the brightness values have been set, command the LED // to those values analogWrite(RED_PIN, redIntensity); analogWrite(BLUE_PIN, blueIntensity); analogWrite(GREEN_PIN, greenIntensity); } |
Compilamos y subimos
Nuestro PCB deberá mostrar el siguiente Patrón de Colores, Rojo, Verde, Azul
Conclusiones cómo fabricar una PCB desde cero
Sin duda alguna, cuando estamos creando nuestros proyectos Maker debemos ser conscientes de todo lo que necesitamos saber. No es algo nuevo, si ya estás metido en el mundo Arduino, la programación y la electrónica son dos materias que debes dominar.
Pero cuando ya tenemos soltura armando nuestros circuitos, debemos seguir avanzando. El siguiente paso natural es fabricar nuestra propia PCB.
Es recomendable empezar con algo sencillo que nos permita ir avanzando y aprendiendo poco a poco. Es la única forma de conseguir objetivos. Recuerda que más vale un prototipo mínimo aunque sea feo pero funcional a no tener nada de nada.
En este artículo hemos empezando viendo cómo debes trabajar con una protoboard y los componentes básicos recomendados para empezar. En esta fase tenemos el esquema eléctrico y el circuito. Estos dos diagramas son esenciales para entender qué estamos haciendo.
Una vez que lo tenemos claro pasamos a armar el circuito en la protoboard. Comprobamos que todo funciona según lo esperado y ya podemos pasar a armar el circuito en una placa pre-perforada. No te olvides de soldar. La única manera de adquirir experiencia es practicando, no queda otra.
¿Has fabricado alguna vez una PCB?
¿Tienes algún diseño de PCB interesante que quieras compartir?
Cualquier duda, sugerencia o comentario aquí abajo por favor. Muchas gracias.
