Hola foreros. Continuando con las ULP (User Language Programs), vamos a ver un programita llamado
copiar_layout.ulp del que tomé prestado parte del código de cplayout.ulp y export-board.ulp que se puede obtener de la direccion
www.cadsoftusa.com en la seccion de
download -> ULP.
Cualquier error, falla, bueno ya saben, a corregir
Con este programa vamos hacer una herramienta útil, supongamos que tenemos un layout que tiene muchos componentes, ruteado manualmente, etc. y que por
X causa debemos desechar ese board y crear uno nuevo a partir del esquematico (schematic).
Entonces una posible solución sería crear un script que nos ayudara a copiar todo ese layout (lo mas aproximado posible) para evitar tener que empezar de nuevo.
Usemos pues la programacion de usuario que nos brinda el Eagle para hacer el script.
Lo primero a tomar en cuenta es que vamos a trabajar en el board, así que el objeto que vamos a utilizar es:
cabe decir que existen 3 tipos de objetos y son: Library, schematic y board que pueden ser accesado a traves de los miembros (tomado de la ayuda del Eagle)
para que el usuario sepa donde debe ejecutar el ULP, nos aseguramos:
if (board) // pregunta si estamos en el board
board(B){ //ejecuta el codigo principal
...
...
}
else{ // no estamos en el board :((
dlgMessageBox(": Error:\n\n Debes correr esta ULP en el board !\n");
}
Esta ulp lo que hará es crear un script para poder usarlo posteriormente, así que debemos crear un archivo primero donde se alojará todos los comandos requeridos.
para crear un archivo:
string fileName = dlgFileSave("Save File", filesetext(B.name, ".scr"), "*.scr");
para guardar datos en el archivo .scr, usamos printf(), pero todo encerrado en la función output()
output(fileName) {
....
}
A partir de aquí se irá llamando a los distintos miembros que necesitemos para copiar el contenido del board. para comenzar copiemos todos los rectangulos que existan en nuestro board (eso incluye los famosos tRestrict y bRestrict que usamos para evitar el ruteo en ciertas zona), para ello llamamos a rectangles() que es un miembro de lazo (loop member)
B.rectangles(REC) { // revisa todos los rectangulos
printf("LAYER %d;\n", REC.
layer); //identifica en que capas esta el rectangulo printf("RECT (%5.3f %5.3f) (%5.3f %5.3f);\n", u2mil
(REC.
x1), u2mil
(REC.
y1), u2mil(REC.x2), u2mil(REC.y2));
// crea el nuevo rectangulo según la capa
}
fijense que ahí usamos la función u2mil, quiere decir que convertirá los valores xn e yn en unidades MIL (MIL corresponde a 1/1000 pulgada), se usa esa unidad para definir a lo largo del programa un unico sistema. Ya que trabajaremos en esa unidad es bueno saber que debemos colocar despues del output, esto:
recuerden que el script hace lo mismo que nosotros hacemos con el mouse/teclado pero de forma automatizada, con esa función cambiamos en el board el sistema metrico, (porque si no se hace, van a salir errores de coordenadas).
si ejecutaramos esta ulp hasta aquí (si no hubiera errores, ¡claro!
), por ejemplo en un board que tuviera un solo rectangulo en la capa TOP, con ciertas coordenadas
se crearía el archivo .scr y al abrirlo veriamos lo siguiente:
GRID MIL 50
LAYER 1;
RECT (1050.000 700.000) (4350.000 2700.000);
Que es lo mismo que si lo ejecutaramos a mano, y se crearía el mismo rectangulo en la capa TOP, pero mediante código.
Bueno pero a este código le falta todavía, ahora vamos a copiar los componentes que existan en el board, mediante el miembro elements
B.elements(E) {
//aqui va todos los miembros que pertenezcan a elements
}
los miembros que pertenecen a elements son los siguientes:
de los que se muestra en la imagen se usaran (por el momento): name, angle, x,y.
Para name y la ubicación de los componentes:
printf("move %s (%5.0f %5.0f)\n",E.
name,u2mil
(E.
x),u2mil
(E.
y));
para el angle se hará de la siguiente manera:
if(E.angle==90)
printf("rotate (%5.0f %5.0f)\n",u2mil
(E.
x),u2mil
(E.
y)); else
if(E.angle==180){
printf("rotate (%5.0f %5.0f)\n",u2mil
(E.
x),u2mil
(E.
y)); printf("rotate (%5.0f %5.0f)\n",u2mil
(E.
x),u2mil
(E.
y)); }
else
if(E.angle==270){
printf("rotate (%5.0f %5.0f)\n",u2mil
(E.
x),u2mil
(E.
y)); printf("rotate (%5.0f %5.0f)\n",u2mil
(E.
x),u2mil
(E.
y)); printf("rotate (%5.0f %5.0f)\n",u2mil
(E.
x),u2mil
(E.
y)); }
En este caso(para no complicar mucho), se aceptaran estos tres tipos de rotaciones.
Ahora viene otra parte importante, el cableado, las pistas que tambien se puede generar mediante scripts. Para ello usaremos el miembro wire y vias que son llamadas a su vez por el miembro signal.
B.signals(S){
S.wires(W) {
printf("wire '%s' %d %3.0f (%5.3f %5.3f) (%5.3f %5.3f)\n", S.name, W.layer, u2mil(W.width),u2mil(W.x1),u2mil(W.y1),
u2mil(W.x2),u2mil(W.y2));
}
S.vias(V){
printf("via '%s' round %5.3f ( %5.3f %5.3f)\n", S.name,u2mil(V.diameter[1]),u2mil(V.x),u2mil(V.y));
}
El rectangulo blanco que siempre bordea el layout, que no es mas que un wire, se puede generar:
B.wires(WIR){ // es para el wire (layer20 dimension) el rectangulo blanco
printf("LAYER %d\n", WIR.
layer); printf("WIRE %5.3f (%5.3f %5.3f) (%5.3f %5.3f);\n", u2mil
(WIR.
width), u2mi(WIR.x1), u2mil(WIR.y1), u2mil(WIR.x2), u2mil(WIR.y2));
}
Nota: los wires que se manejan entre las capas 1 al 16 son tratados como conexiones electricas (signals), y por tanto se debe llamar desde el miembro signal, mientras que en caso de la capa (layer) 20 dimension se puede manejar el wires directamente desde el objeto board.
Hay que decir que miembros como las coordenadas x e y, siempre que se utilice, hay que tomar en cuenta la capa involucrada, por eso se declara antes el comando "layer w.layer"
para las donas, podemos generar el tamaño de los huecos(drill) originales.
B.holes(huecos){
printf("CHANGE DRILL %d\n",u2mil
(huecos.
drill)); }
finalmente para restaurar los valores iniciales del board colocamos los siguientes comandos:
printf("GRID LAST\n"); // restaura el sistema de unidades anterior printf("Window Fit\n"); // acomoda el layout a la mejor vista
Probemos este ULP, con el layout hexapod.brd, que se encuentra en el directorio del Eagle
1.- Copiamos el hexapod.sch con el nombre hexapod_otro.sch (sin el board)
2.- abrimos hexapod.brd y cargamos nuestra ulp
3.- guardaremos el script con ese nombre
4.- cerramos hexapod.brd y abrimos desde el esquematico a hexapod_otro.sch
5.- crearemos a hexapod_otro.brd y nos quedará así
6.- Clicamos en el icono SCR y cargamos a hexapod.scr
Observen que tenemos 2 rectangulos de color blanco, el que crea por defecto el board y el que generamos con el script, simplemente borramos el rectangulo grande.
Puedes bajar todo que está en el adjunto, tambien con las ULP´s originales.
Es obvio que se puede hacer mas potente este humilde ULP, como la capacidad de copiar los textos, rotación a cualquier angulo, copiar polígonos (para crear el plano a masa, etc).
Pero vamos poco a poco, todavía falta mucho por aprender, je je
Salu2