Construcción de la placa de circuito

En este post se mostró el diseño de la placa de circuitos para controlar el LED RGB con el Arduino. Iniciamos el proceso de construcción, para el cual se requirió preparar el entorno de trabajo:

  • Placa perforada para prototipos.
  • Cautín, de 45Watts.
  • Estaño para soldar.
  • Tercera mano.
  • Desoldador.
  • Pinzas varias.
  • Herramienta pelacables.
  • Cable de red pelado.
  • Componentes electrónicos.
  • Pines, precortados en la cantidad deseada.
  • Marcador.
  • Mucha, pero mucha, paciencia.

Iniciamos el proceso siguiendo el diseño, aunque fue reinterpretado en el momento dado el tamaño de las resistencias (de 2 y 1.5Watts).

El primer caso es colocar los componentes, cortar y doblar las patillas:

Una vez fijadas, se sueldan los puntos de apoyo:

Este es el resultado final de soldadura, ya con los cables:

Este es el resultado final del trabajo, con las cables de la LED ya instalados, el soporte y las marcas indicativas:

Pueden observar el funcionamiento de la misma en el siguiente vídeo de prueba:

El código cargado en el Arduino para esta demostración es el siguiente:

/**
* Flame Of Knowledge - LED driver
*
* @license Code: GNU/GPL http://www.gnu.org/licenses/gpl.html
* @author Havok - Carlos Jenkins Pérez
* @copyright Carlos Jenkins, 2010
* @link http://www.cjenkins.net/
*
*/

// Hardware channels
const byte redPin = 11;
const byte greenPin = 10;
const byte bluePin = 9;

const byte debugPin = 13; //DEBUG

// Channels color values
byte red = 0;
byte green = 0;
byte blue = 0;

void setup() {

// Initialize the led channels as outputs
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);

// DEBUG
pinMode(debugPin, OUTPUT);
}

void loop() {

const unsigned int wait = 4000;

//"Red" (255, 0, 0 )
fadeTo(255, 0, 0, wait);

//"Yellow" (255, 255, 0 )
fadeTo(255, 255, 0, wait);

//"Green" (0, 255, 0 )
fadeTo(0, 255, 0, wait);

//"Cyan" (0, 255, 255)
fadeTo(0, 255, 255, wait);

//"Blue" (0, 0, 255)
fadeTo(0, 0, 255, wait);

//"Magenta" (255, 0, 255)
fadeTo(255, 0, 255, wait);

//"White" (255, 255, 255)
fadeTo(255, 255, 255, wait);

//"Black" (0, 0, 0)
fadeTo(0, 0, 0, wait);

}

void fadeTo(byte desiredRed, byte desiredGreen, byte desiredBlue, unsigned int desiredTime) {

// Calculate the required loops
byte steps =
max(1, // Check if cero to avoid division by cero
max(
max(
abs(red - desiredRed), abs(green - desiredGreen)
), abs(blue - desiredBlue)
)
);

// Calculate delay
int milliseconds = desiredTime / steps;

// Fade all channels at the same time
for(int i = 0; i <= steps; i++) {

// Check the red channel
if(red != desiredRed) {
if(red < desiredRed) {
red++;
} else {
red--;
}
analogWrite(redPin, red);
}

// Check the green channel
if(green != desiredGreen) {
if(green < desiredGreen) {
green++;
} else {
green--;
}
analogWrite(greenPin, green);
}

// Check the blue channel
if(blue != desiredBlue) {
if(blue < desiredBlue) {
blue++;
} else {
blue--;
}
analogWrite(bluePin, blue);
}

// Delay this loop
delay(milliseconds);

}

return;

}

// DEBUG
void flag() {
digitalWrite(debugPin, HIGH); // Sets the LED on
delay(250); // Waits for a 250 millis
digitalWrite(debugPin, LOW); // Sets the LED off
delay(250); // Waits for a 250 millis
}

Anuncios

Distribución de las ramas y conectores del PSU

La PSU tiene las siguientes ramas y conectores:

  • Rama 1:
    • 1 conector para la MB.
  • Rama 2:
    • 1 conector para el CPU de 8 pines.
    • 1 conector para el CPU de 8 pines (4 y 4).
  • Rama 3:
    • 5 conectores de 4 pines Molex para periféricos.
  • Rama 4 y 5:
    • 4 conectores SATA.
  • Rama 6 y 7:
    • 1 conector PCI Express de 6 pines.
    • 1 conector PCI Express de 8 pines (6 y 2).

Como puede ser observado en la siguiente fotografía:

 

Los conectores estarán distribuídos de la siguiente manera:

  • Rama 1:
    • Conectado a la tarjeta madre, nivel 1.
  • Rama 2:
    • Primer conector libre.
    • Segundo conector conectado a la tarjeta madre, nivel 1.
  • Rama 3:
    • Primer y quinto conector conectados a los ventiladores inferiores, nivel 0.
    • Segundo y cuarto conector conectados a ventiladores laterales, nivel 1.
    • Tercer conector conectado a driver de LED principal, nivel 2.
  • Rama 4 y 5:
    • Conector 1 y 3 conectados a CD-ROMs izquierdos/derechos.
    • Conector 2 inusable dado la posición de los CD-ROMs.
    • Conector 4 libre.
  • Rama 6:
    • Conector 1 libre.
    • Conector 2 conectado al touchscreen.
  • Rama 7:
    • Ambos conectores libres.

Nota: Conectores numerados del más cercano al PSU, empezando desde 1, hasta el extremo de la rama.

Elaboración de rejillas de ventiladores

Como se puede observar en este post el FoK tiene un ventilador derecho y uno izquierdo fijado sobre el acrílico. Para tapar estos ventiladores se creó unas rejillas en acrílico. Estas rejillas fueron grabadas y cortadas con laser. Pueden observar los diseños utilizados (realizados con Inkscape):

Pueden descargar el archivo fuente (FanGrids.svg) del repositorio de código.

Las rejillas fueron grabadas y cortadas con laser en material acrílico (polymethyl metacrilato) de 4mm de espesor. Fueron diseñadas para ventiladores de 120mm y tienen una dimensión de 160mm x 160mm, dejando 2cm para poder fijarlas a la superficie de soporte.

El proceso completo de grabado y corte pueden observarlo en el siguiente vídeo:

El resultado final es el siguiente:

Touchscreen alimentado por la PSU

Uno de los propósitos del FoK es ser una unidad autocontenida y para ello es necesario reducir los cables de electricidad de la unidad. Dados los componentes internos actuales existen dos cables de poder: el de la PSU y el del touchscreen.

El cable de poder del touchscreen se conecta a un adaptador:

Este adaptador tiene una salida de corriente continua con una tensión de 12V y una intensidad eléctrica máxima de 4.2A. La polaridad del conector al touchscreen es: centro positivo, exterior negativo.

Para reducir la cantidad de cables de electricidad necesarios del FoK analizamos la posibilidad de alimentar el touchscreen con la PSU. En próximo post podremos observar que la PSU tiene todos los conectores PSI Express libres:

Estos conectores tienen el siguiente pinout:

Pueden descargar los archivos fuente (PCIExpressConnector.svg) del repositorio de código.

Además, cada riel de +12V soporta una intensidad eléctrica máxima de 19A, y dado que contamos con ambas ramas PCI Express libres podemos costear los 4.2A máximos necesarios del touchscreen sin ningún problema.

Por lo tanto, es necesario construir un adaptador de conector PCI Express a un conector de barril de 5mm a 6mm de diámetro exterior (no lo se con precisión, necesito calipers de cualquier tipo, ojalá digitales :S) y de 2mm a 3mm de diametro interior.

Nota: Un valor común de conectores de barril es de 6mm y 3mm respectivamente.

Fijación del touchscreen a la estructura

Ahora que llegaron los paquetes podemos confirmar la forma del touchscreen y cómo podría ser fijado a la estructura. En el siguiente vídeo pueden ver como está hecha la base del touchscreen. La tapa superior fue pre-desatornillada para el vídeo. Disculpen el temblor al desatornillar, es difícil desatornirllar con una mano y filmar al mismo tiempo (se me olvidó el trípode).

Podemos observar que existe un soporte fijado a la parte superior de la pantalla:

Para la estructura, podemos colocar barras transversales entre los niveles y que el touchscreen se apoye sobre ellas, atornillando el soporte del touchscreen a dichas barras: