El domingo Maria cumple 12 años. En esta ocasión he hecho una cajita retroiluminada con tres LEDs SMD. La electrónica no es difícil, se trata de un timer 555 configurado para que esté encendido durante 15 minutos. Ha de servir como punto de luz en la habitación cuando los chavales se van a la cama.

El proyecto lo he diseñado primero con Eagle CADSoft, y luego con KiCAD, pues de hecho estoy migrando a KiCAD, como tiene que ser. El prototipo de la placa PCB lo he hecho con la fresadora. Ya tenía experiencia del año pasado de utilizar el script pcb2gcode con el Eagle, y ahora lo estoy utilizando con el KiCAD, con resultados muy buenos.

El Timer 555 se puede configurar como temporizador o para hacer pulsos. En nuestro caso, hemos optado por un diseño de manera que cuando pulsemos el botón se enciendan los LEDs durante 15 minutos. Los 15 minutos se consiguen escogiendo los valores adecuados de R y C (recordar que RxC tiene unidades de tiempo). He escogido un TLC555CD para minimizar el consum . El TLC555CD es SMD y tiene formato SOIC. La idea es alimentarlo todo con 3V y minimizar al máximo el consum durante los periodos de stand-by, pues se alimenta con 2 piles AAA i se espera que duren bastante tiempo.

He ensayado con la soldadura SMD, de la que no soy ningún experto. El timer TLC555CD (format SOIC-8) lo he soldado manualmente, y ha quedado una soldadura bastante limpia. Los LEDs también son SMD. Si tuviera que hacer otra unidad, probariía con la soldadura SMD al horno.

Este sería un proyecto interesante para hacer muchas unidades en serie, de hecho ya estuve mirando proveedores para aprovisionar una buena cantidad de los componentes. La idea es que todos los componentes fueran SMD, y entonces sí que haría un pedido de placas PCB a un fabricante, pues ahora los precios son razonables.

Cuanto a la parte del fresado la madera es DM de 2mm. Todos los cortes están hechos con la fresadora, así como las letras, donde se ha escogido la fuente Black Rose. La parte más crítica es montar la cajita con los ángulos bien rectos, y pintarlo todo y que quede perfecto. Detrás de las letras se pone un metacrilato blanco, también cortado con la CNC.

Por tanto, es un proyecto simple pero finalmente más laborioso de lo que creía, y ciertamente se puede automatizar en gran medida para hacer una tirada grande. Lo que no se puede automatizar son los nombres que hay que fresar, esto sí que es bajo demanda.

Referencias:

Hemos estado programando un script en C++ para hacer cavidades. Cavidades de diferente tipo: rectangulares, rectangulares con cantos redondeados, circulares y elípticas. Además, la profundidad de la cavidad puede ser constante (cavidad cilíndrica) o bien una cavidad esférica. Por tanto, hay 8 posibilidades de cavidades diferentes, como se ve en la imagen, con diversos parámetros que puedes controlar. El script genera el G-Code directo para ser fresado.

Si quieres utilizar el script, primero tendrás que mirar las ilustraciones que hay en la documentación, y así entender los diferentes parámetros. Básicamente tenemos que introducir el origen de coordenadas de la cavidad (allá donde está centrada); los semiejes en el caso de los rectángulos-elipse, o el radio en el caso del círculo; la profundidad final en el caso de cavidades cilíndricas; el radio esférico en el caso de cavidades esféricas, que dará lugar a más o menos profundidad esférica. En función de la broca que tengamos y de la resolución que queramos, también hemos de definir el paso lineal y el paso de profundidad (parámetros -m y -n).

Para las cavidades cilíndricas hay suficiente con utilizar brocas normales de fresar (las de 2mm de diámetro son las más pequeñas que he conseguido). Pero para las cavidades esféricas es interesante utilizar una broca tipo round nose bit, y así conseguimos un mejor acabado, como se puede apreciar en la foto.

El primer proyecto para utilizar mis cavidades es fresar el juego del mancala (o awalé o otros nombres), donde quiero fresar varias cavidades diferentes. Ya informaremos cuando esté acabado.

Es un proyecto escrito en C++, no requiere ninguna librería especial, por tanto su compilación es directa. Para la versión 1.0.6, la última versión:

$ g++ -o cnchollow cnchollow-1.0.6.cpp
Ex:
$ ./cnchollow -f rectangle -t cylindrical -x 100 -y 100 -r 30.23 -s 15.21 -z -10.3 -m 3.0 -n -1.0 -o ./cnchollow.ngc


Referencias:

Estos días estamos viviendo unos días inciertos en Catalunya. Es necesario salir a la calle y defensar el gobierno legítimo, rehusar de pleno la aplicación del artículo 155 de la Constitución Española, y no dejar pasar la oportunidad que representa las elecciones del 21D. Así que hemos hecho unos carteles para llevarlos a la manifestación del 11N, y todas las que sean necesarias. Actualmente, tenemos en las prisiones españolas: Jordi Sánchez, Jordi Cuixart, Oriol Junqueras, Dolors Bassa, Meritxell Borràs, Josep Rull, Raül Romeva, Carles Mundó, Joaquim Forn y Jordi Turull. Y el número puede aumentar.

Aquí expongo mi workflow para hacer un cartel en blanco y negro, a partir de una foto.

1. GIMP. A la hora de escoger la foto hemos de procurar que el fondo sea claro y contrastado con la foto, de manera que el GIMP detecte bien los contornos. Abrimos la foto con el GIMP, y desaturamos la foto (convertiéndola a escala de grises), y con la herramienta Umbral de color blanco-negro, escogemos la imagen que queremos fresar.

2. LibreCAD es el software que utilizo para generar el DXF. Importo la imagen, y creo una capa para definir las líneas de fresado. Como la broca que utilizaré es de 2mm, escojo un trazo de 2mm, y de esta manera me puedo hacer una buena idea de cómo quedará el resultado final. Resigo todos los contornos, lo hago de manera manual.

3. Todavía en el LibreCAD, he de definir los puentes de manera que no haya ninguna isla que se pueda desprender cuando después haga el fresado. Genero el fichero dxf.

4. Vuelvo al GIMP y relleno de negro las superfícies que quedarán vacías. De esta manera me puedo hacer una buena idea del resultado final, y prever el éxito de la pieza.

5. Con el script de python dxf2gcode puedo definir las propiedades del fresado. Concretamente, la profundidad del corte. Si la plancha de madera que utilizaré es de 3mm, la profundidad será de 3mm. Genero el fichero G-Code.

6. Con LinuxCNC ya puedo fresar la pieza, con una broca de 2mm. Una vez finalizado el trabajo, se lija y se corrigen posibles imperfecciones.

Todo el proceso está explicado en el video. En la imagen se ve cómo queda el resultado final con la foto de Raül Romeva, ahora en prisión. Ahora sólo queda hacer los carteles, y salir a la calle. La lucha continua.

Referencias:

Estos días estoy haciendo una nueva máquina de Pinball, igual que la primera, con configuración FS (FullScreen), es decir, de una sola pantalla. Aprovechando que tengo un ordinador con el que hacer pruebas, en un segundo disco quiero instalar el Visual Pinball con configuración B2S (Backglass to Screen), es decir, con dos pantallas: la principal es el playfield, y la secundaria es el backglass.

Así pues he instalado el Visual Pinball y el VPinMAME, y he mirado los tutoriales para ver cómo funciona esto del B2S. Y ya tengo las primeras mesas funcionando. No es difícil de entender y de implementar, pero lo que sí es cierto es que tendré que ir una por una de las más de 200 mesas que tengo implementadas y clasificadas.

Lo primero que hay que hacer es bajarse los archivos de backglass (con extensión .directb2s). A partir de las dos pantallas que tengo (una de 22” 1920×1080; y otra de 17” 1280×1024), creo el fichero screenres.txt, relacionado con la geometría de las dos pantallas. Y entonces he de ir una por una de las mesas, entrar en el script (el código), y configurar el script para que funcione el modo B2S. Ejecutar la mesa (jugar un rato :-) ), comprobar que todo funcione correctamente, y ajustar algún parámetro si es necesario. En particular, las mesas que tienen DMD (Dot Matrix Display), ajustaré la geometría para que el display DMD aparezca en la pantalla del backglass, en una posición que no sea invasiva.

En la configuración FS tengo implementadas 200 mesas. Algunas de ellas no se han portado todavía a B2S, pues no tienen el fichero de backglass, o me han dado problemas. Si tengo tiempo, miraré de implementar algunas mesas más que vea que son divertidas, y así recuperar el valor de 200 mesas implementadas. En el futuro, miraré de introducir el display de DMD, aunque yo siempre tengo un ojo puesto en la simplicidad.

Cuando tenga configuradas las mesas B2S será el momento de hacer el mueble de pinball con dos pantalls, de momento en un formato pequeño: pantallas de 22” y 17”, y un mueble lo más pequeño posible que integre estas dos pantallas. Esta será la parte más divertida y original. Además, si tengo tiempo, quiero poner un plunger analógico, un accelerómetro para el nudge, y un monedero. Pero esto será otra historia. De momento ya hay mucha faena configurando las mesas B2S.

Estoy en el proceso de migrar de Eagle CadSoft a KiCAD (open source), y además utilizar componentes SMD en los nuevos proyectos. Por tanto, he de practicar la soldadura SMD, y tener las herramientas adecuadas.

Hay muchos videotutoriales de soldadura SMD, interesante ver alguno para coger confianza y evitar errores. Básicamente hay tres maneras de hacer la soldadura SMD:

  1. Soldando a mano, con un soldador de punta muy fina e hilo de estaño fino. Es fácil soldar de esta manera cuando los componentes no son muy pequeños (por ejemplo 0805 o superiores).
  2. Con pasta de soldar, y utilizando un horno a 230º. Vale la pena sobretodo cuando hay bastantes componentes a soldar. Esta sería la manera definitiva para hacer una tirada más grande, pues se pueden poner en el horno varias placas a la vez. La gran ventaja de la pasta de soldar es que una vez situado el componente, éste no se mueve.
  3. Con pasta de soldar y aire caliente de una estación de soldadura. Todavía no lo he probado pero tendría que funcionar. Sería correcto para soldar algún componente puntual.
  4. En la fotografía se muestra el resultado de la primera prueba que he hecho en el horno de casa, a unos 230 grados. El gran éxito de la soldadura fina es confiar en la tensión superficial que se genera entre el flux soldante, el estaño y el componente. La tensión superficial es la que evita que el estaño se esparza y haga puentes entre las pistas.

    Mi workflow de prototipaje:

    • KICAD
    • Generación de los Gerbers
    • pcg2gcode para generar el G-Code para la máquina CNC
    • Fresado CNC
    • Flux: Resina de colofonia
    • Soldar: componentes SMD y componentes through-hole

    Una vez el prototipo funciona, lo más correcto es encargar las placas a algún fabricante de PCBs, ahora hay muchos y a buen precio, con más o menos tiempo de espera.

    Notas de soldadura en la wiki.

Hace unos días que he acabado el tablero de Xiangqi y las piezas, y ya he jugado algunas partidas. He estado probando diferentes maneras de rellenar con color negro o rojo las piezas. Las piezas negras (y el tablero) los he rellenado con silicona negra. El resultado es correcto, pero el problema es que al barnizarlo queda un poco pegajoso. Es por esto que finalmente el tablero no lo he barnizado. Las piezas rojas las he rellenado con Aquaplast mezclado con pintura acrílica roja, y el resultado es más que correcto. Me gustaría hacer más pruebas, por ejemplo algún otro tipo de silicona o bien resina epoxi o de poliéster.

Como mi máquina CNC es de 30x40cm, el tablero lo he tenido que dividir en dos parts, que he tenido que juntar con cola blanca y espigas de madera. El tablero es de madera de pino, y las fichas son de madera de boj de 5 cm de diámetro. Es un proceso lento y laborioso hacer las fichas de una en una (son 32 piezas en total). Evidentmente, el proceso sería mucho más rápido utilizando un tablero de pino.

A lo largo del proceso de construcción he hecho unas cuantas fotos, cuelgo un video de todo el proceso. Para mejorar el procedimiento de barnizado, he hecho un jig donde puedo barnizar por delante y por atrás las piezas de 8 en 8.

Creo un proyecto con LibreCAD, creo la capa ”stroke”, y aquí metemos las polilíneas, tal como se ha explicado en el anterior artículo [1], y tal como se muestra en la imagen. Con lenguaje C++, lo primero que hacemos es leer el fichero dxf y detectar la capa stroke, con todos sus puntos. En el LibreCAD todas las líneas son iguales, tienen un origen y un final. Pero a mi me interesa detectar las polilíneas, que son las líneas enlazadas de manera que el punt final de una línea es el mismo que el punto de origen de la línea siguiente. Recordemos la estructura de datos que se utiliza:

struct linia {
int x0;
int y0;
int x1;
int y1;
double length;
};

struct polilinia {
std::vector vlinia;
double length;
};

std::vector vpolilinia;

Recorremos todas las líneas, y vamos añadiendo elementos al vector polilínea, y dentro de cada polilínea vamos añadiendo elementos al vector línea. Para cada línea y para cada polilínea, tenemos calculada su longitud. Una vez tenemos rellenado el vector de polilíneas con sus líneas, ya podemos recorrer todas las polilíneas y generar la salida G-Code, de manera que el inicio de una polilínea está a profundidad -2mm, y el final de la polilínea está a profundidad 0mm, tal como se aprecia en este trozo del G-Code resultante, y en la imagen:

(* POLILINE #2 *)
G0 X 30 Y 30
G0 Z 3.000
F150
G1 Z -2.0
F400
G1 X 50 Y 40 Z -1.11
G1 X 60 Y 30 Z -0.55
G1 X 70 Y 40 Z 0
F150
G0 Z 5.000

Como se aprecia en el G-Code, posicionamos la broca en el punto (30,30), agujereamos hasta -2.0mm, y vamos pasando por tres puntos sucesivos mientras vamos levantando de forma proporcional la broca hasta llegar al punto (70,40), punto en que la broca deja de atacar la superficie. Así conseguimos un trazo variable, tal como se aprecia en la imagen. Con esta técnica podremos perfilar detalles en los trabajos CNC, como pueden ser los cabellos de un retrato, o el trazo en una caligrafía.

Como se aprecia en la imagen (extraída del proyecto de fresar el retrato de Albert Einstein en blanco y negro, en otra entrada mostraremos el resultado final), se ve el resultado de aplicar el script cncstroke para las polilíneas agrupadas en la capa stroke del proyecto LibreCAD. Vemos dos trazos que acaban en punta (en la part izquierda de la imagen, sobre madera), y otro trazo, donde no se ha aplicado el script, que no acaba en punta. En la parte derecha de la imagen vemos un trozo del proyecto LibreCAD donde se han definido estas líneas (dos que pertenecen a la capa cncstroke, y otra que se fresa normal). Así pues, con un uso correcto del proyecto LibreCAD, podemos aumentar la resolución del fresado CNC, consiguiendo un efecto más real y detallado.

Puedes descargar y estudiar el código del script cncstroke desde el siguiente enlace [2] .
Referències:

Nota aclarativa: En el proyecto cncstroke utilizamos el término polilínea como sucesión de líneas enlazadas. Ahora bien, para generar estas líneas enlazadas, en LibreCAD, utilizamos la herramienta línea (y no la herramienta polilínea) (En una futura versión se estudiará la posibilidad de utilizar la herramienta polilínea, o ambas).

Uno de los trabajos típicos que se hacen con la CNC es el retrato de personajes en formato blanco y negro. Por ejemplo, son conocidos los retratos del Che Guevara o Albert Einstein. Estos días estoy trabajando con la imagen de Ovidi Montllor [1].

La idea es sencilla y conocida. Importo la imagen en LibreCAD [2] (el software CAD que utilizo, que es open source), defino la silueta, y defino unas áreas de hatching que seran fresades (rebajadas). Utilizo el programa dxf2gcode [3] para exportar a G-Code, y freso todo el trabajo a una profundidad de 1.5mm. La limitación que tengo es que la fresa que utilizo es de 2mm de diámetro, y esto limita la resolución final que pudo alcanzar.

Estoy programando un pequeño script (cncstroke [4]) para mejorar la resolución de mis trabajos. Imaginemos por ejemplo los cabellos de Albert Einstein. Lo ideal es que las mechas de cabello acaben en punta, haciendo un trazo que pase de grueso a fino. Esto se consigue haciendo que la profundidad de ataque de la broca sea variable, desde 1.5mm de profundidad en el inicio del trazo hasta 0mm al final del trazo. Pero para que el invento funcione, no he de utilizar una broca normal, sino una broca V-Shape (con punta de 40 grados). De esta manera conseguiré el efecto de hacer un trazo que pase de 2mm de ancho en el origen a 0 mm en el extremo. Esta técnica también será muy útil para fresar letras que simulen trazos variables.

La idea es que en els mis proyectos de LibreCAD tendré una capa con la silueta básica (que fresaré con una broca de 2mm), y una capa (que siempre nombraré stroke) que constará de polilíneas que representarán el trazo variable desde 2mm hasta a 0 mm de ancho. Con esta segunda capa podré hacer los detalles como cabellos o caligrafía de letras.

En este primer artículo sólo expongo la estructura de datos que me permitirá gestionar la generación del G-Code a partir del proyecto de LibreCAD. Cuando recorra (programáticamente) el contenido de un proyecto LibreCAD (formato dxf), tendré que buscar la definición de la capa stroke y de los puntos que contiene. Esto es relativamente fácil de hacer. Esta sucesión de puntos se pueden agrupar en polilíneas, entendiendo que una polilínea es un conjunto de líneas que van empalmadas.

Como el número de poliíneas es variable, y el número de líneas que contiene una polilínea también es variable, la mejor manera de programar esta estructura con lenguaje C++ es utilizar vectores.

struct linia {
int x0;
int y0;
int x1;
int y1;
double dist;
};

struct polilinia {
std::vector vlinia;
double dist;
};

std::vector vpolilinia;

Una línea consta de un punto origen y de un punto final (fácilmente se podrá calcular la longitud de esta línea). Una polilínea consta de un conjunto de líneas, y la longitud de la polilínea será la suma de les longitudes individuales.

A continuación mostramos el ejemplo mínimo de cómo se pueden gestionar diferentes polilíneas, cada una con un número variable de líneas.

// g++ -o polilinia polilinia.cpp
#include
#include
#include
#include
#include

struct linia {
int x0;
int y0;
int x1;
int y1;
double length;
};

struct polilinia {
std::vector vlinia;
double length;
};

std::vector vpolilinia;

using namespace std;

int main() {

double lengthlinia,lengthpolilinia;
polilinia polilinia1;
linia linia1;

lengthpolilinia=0;

linia1.x0=34;
linia1.y0=30;
linia1.x1=120;
linia1.y1=122;
lengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
linia1.length=lengthlinia;
lengthpolilinia += lengthlinia;

polilinia1.vlinia.push_back(linia1);

linia1.x0=320;
linia1.y0=322;
linia1.x1=420;
linia1.y1=422;
lengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
linia1.length=lengthlinia;
lengthpolilinia += lengthlinia;

polilinia1.vlinia.push_back(linia1);

polilinia1.length = lengthpolilinia;

vpolilinia.push_back(polilinia1);

//cout << vpolilinia.at(0).vlinia.size() << endl;

//anem per una altra polilinia
polilinia1.vlinia.clear();
lengthpolilinia=0;

linia1.x0=134;
linia1.y0=130;
linia1.x1=220;
linia1.y1=222;
lengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
linia1.length=lengthlinia;
lengthpolilinia += lengthlinia;

polilinia1.vlinia.push_back(linia1);

linia1.x0=220;
linia1.y0=222;
linia1.x1=320;
linia1.y1=322;
lengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
linia1.length=lengthlinia;
lengthpolilinia += lengthlinia;

polilinia1.vlinia.push_back(linia1);

linia1.x0=220;
linia1.y0=222;
linia1.x1=320;
linia1.y1=322;
lengthlinia = sqrt(pow(linia1.x1-linia1.x0,2) + pow(linia1.y1-linia1.y0,2));
linia1.length=lengthlinia;
lengthpolilinia += lengthlinia;

polilinia1.vlinia.push_back(linia1);

polilinia1.length = lengthpolilinia;

vpolilinia.push_back(polilinia1);

//cout << vpolilinia.at(1).vlinia.size() << endl;
//cout << vpolilinia.size() << endl;

//recorrem totes les polilínies
for (int i=0; i cout << "polilinia #" << i << ". length: " << vpolilinia.at(i).length << endl;
//dins de cada polilinia, recorrem les línies:
for (int j=0; j cout << "linia #" << j << ". length: " << vpolilinia.at(i).vlinia.at(j).length << endl;
}
}
}

I la sortida per pantalla:

$ ./polilinia
polilinia #0. length: 267.358
linia #0. length: 125.936
linia #1. length: 141.421
polilinia #1. length: 408.779
linia #0. length: 125.936
linia #1. length: 141.421
linia #2. length: 141.421

En el siguiente artículo [5] se explica la implementación del proyecto cncstroke para generar G-Code con z-depth variable.

Referencias:

Nota aclarativa: En el proyecto cncstroke utilizamos el término polilínea como sucesión de líneas enlazadas. Ahora bien, para generar estas líneas enlazadas, en LibreCAD, utilizamos la herramienta línea (y no la herramienta polilínea) (En una futura versión se estudiará la posibilidad de utilizar la herramienta polilínea, o ambas).

Estos días he estado perfeccionando cómo hacer un prototipo de PCB con la fresadora CNC.

Antes que nada he tenido que implementar el auto-probe para compensar la nivelación superficial de la placa donde quiero fresar. Este proyecto requiere la máxima precisión. El tema del auto-probe fue especialmente rápido y fácil de conseguir, cosa rara pues las cosas fáciles normalmente se complican de forma inesperada… Está documentado en [1].

Una vez el auto-probe está funcionando, ya puedo mirar de hacer las placas de doble cara. El principal reto está en girar la placa y que los agujeros en una capa y en la otra coincidan exactamente. Como se ve en la foto, esto se ha conseguido bastante bien, y la buena noticia es que hay margen para centrar bien los agujeros en la capa top (pues en la foto se ve que los agujeros no están exactamente centrados). Todo está bien documentado en el enlace [2]

Ahora que ya tengo el proceso bastante claro, ya puedo afrontar un pequeo proyecto que requiere una placa de doble cara. Consiste en montar un mini-ordenador, con finalidad puramente académica, con un microprocesador Z80 [3]. Pero antes de hacerlo, primero vendrá el programador de EEPROM [4], pues al ordenador se le ha de meter un programa en una EEPROM. No sé si todo estará listo antes de vacaciones.

En el pasado había hecho placas con el método UV y con el método de la plancha. Hay que decir que siempre he tenido dificultades varias en consegur placas con cualidad óptima. Ahora, con la CNC, estoy buscando una manera rápida de hacer prototipos. En gran medida creo que lo he conseguido. Ahora bien, el proceso, aunque satisfactorio, es más lento de lo que me pensaba.

Ya hemos acabado la extraescolar de Robótica al Balmes. Este año hemos programado el juego del Simon con una Raspberry Pi. Toda la documentación (y la programación didáctica) está en la wiki [1].

Durante estas 13 sesiones hemos ido trabajando sobre diferentes temas, que nos llevaban al objetivo final de hacer un prototipo de Simon:

  • Hemos programado el script con Python, viajando por las diferentes versiones a medida que necesitábamos incorporar nuevas funcionalidades.
  • Hemos conectado botones y LEDs a los pines GPIO de la RPi.
  • Hemos visto cómo, utilizando transistores, podemos disparar desde los pines GPIO señales de 12V para encender tiras de LEDs blancos.
  • Hemos discutido sobre la alimentación de todo el sistema, y alternativas.
  • Hemos discutido sobre cómo producir el sonido y su amplificación.
  • Hemos diseñado el mueble final, utilizando herramientas de fabricación digital como la impresora 3D y la fresadora CNC.

Al final ha sido un curso muy multidisciplinar, hemos tocado muchas cosas, aunque por falta de tiempo, conocimientos e infraestructura, muchas cosas las ha implementado el professor y las ha mostrado en clase. Pero al final la experiencia ha sido enriquecedora para todos.

El resultado final se puede ver en la foto y en este video:

Referencias:

Page 1 of 1312345»...Last »