Cómo fabricar una PCB desde cero paso a paso

Gustavo Reynaga

hace 7 años

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

1 Quién es Gustavo Reynaga
2 Material para fabricar una PCB desde cero
3 Cómo fabricar una PCB: armado del prototipo
4 Cómo fabricar una PCB: trabajando con tarjetas pre-perforadas
5 Conclusiones cómo fabricar una PCB desde cero

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

/*
  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
}

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.

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

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.