Mis Primeros Pasos en Programación ULP

[PalitroqueZ]

Hola Foreros. Estoy aprendiendo a usar/programar en ULP, que es el lenguaje que trae el Eagle para hacer muchas cosas, y he sacado unos ejemplillos para comenzar, busqué por internet algún manual ó guía y no conseguí mucho, excepto por la ayuda que trae el eagle y las deducciones que hay que hacer con las ulp que se consiguen en cadsoftusa.com
Este lenguaje es similar al lenguaje C, los que ya lo conocen se les hará mas fácil.

Aquí hay 4 ejemplos y en cada uno se irá explicando paso por paso que hace cada linea.

Ejemplo1:

Código: C

1. /* Estudio del lenguaje de programacion del Eagle ULP
2. Ejemplo 1:  en el board
3. datos de entrada= nombre y valores de los componentes
4. datos de salida= mostrar en n ventanas las cadenas con los nombres
5. y valores de los n componentes */
6.  
7. board(B){
8.       // esta estructura indica que se ejecutara solamente en el board
9. string nombre, valor, result;
10.       // declaracion de variables
11.    B.elements(E){
12.       // miembro  para acceder a los elementos involucrados en el board
13.    sprintf(nombre,"El Nombre es: %s\n", E.name);
14.       // toma los nombres de los elementos existentes
15.    sprintf(valor,"El Valor es: %s", E.value);
16.      // toma los valores de los elementos existentes
17.    result=nombre + valor;
18.      // concatena las dos cadenas
19.    dlgMessageBox(result);
20.     // muestra en una ventana de dialogo la cadena
21.    }
22. }

Una vez cargado un layout, se procede a buscar la ULP y ejecutarla:



Para el ejemplo1 mostrará los nombre y valores de todos los componentes en el layout, si clicamos en aceptar mostrará el siguiente componente.



si clicamos en aceptar nuevamente, mostrará el siguiente componente y así sucesivamente hasta completarlos todos.


Ejemplo2:

Código: C

1. /* Estudio del lenguaje de programación del Eagle ULP
2. Ejemplo 2:  en el Board
3. datos de entrada= Nombre y valores de los componentes
4. datos de salida= mostrar en 1 ventana las cadenas con los nombres
5. y valores de los n componentes
6. */
7.  
8. board(B){
9.         // corre solamente en el entorno del board
10. string nombre, valor, result;
11.        // declaración variables
12.    result="      Componentes:\n\n";     // Titulo
13.    result+="Nombre:       Valor:\n";    // Titulo concatenado
14.    B.elements(E){
15.        // igual que el ejemplo1
16.    sprintf(nombre,"    %s", E.name);
17.        //igual que el ejemplo1
18.    sprintf(valor,"             %s\n", E.value);
19.        //igual que el ejemplo1
20.    result+=nombre+valor;                               
21.        //igual que el ejemplo1
22.    }
23.    dlgMessageBox(result);
24.        // se coloco fuera del miembro elements, para evitar bucles de ventanas
25.                 }

Ejecutamos en ULP desde el board



Como se observa en la imagen, el ejemplo2 difiere solo del ejemplo1 en que mostrará los nombres y valores de todos los componentes en una sola ventana.

Ejemplo3:

Código: C

1. /* Estudio del lenguaje de programación del Eagle ULP
2. Ejemplo 3:  en el schematics
3. datos de entrada= nombre y valores de los componentes
4. datos de salida= Crea un archivo llamado ejemplo3.txt en
5. el directorio del eagle, con los nombres y valores de los n componentes
6. */
7.  
8. schematic(S) {
9.  // esta estructura indica que se ejecutará solamente en el esquematico
10. string nombre, valor, result;
11.  // declaración de variables
12.       output("ejemplo3.txt", "wt") {
13.  // con los modos "wt" se crea el archivo y/o se sobreescribe,
14.  // y despues abre el archivo ejemplo3.txt
15.       S.parts(P){       // en el esquematico tenemos el miembro parts  
16.  // miembro  para acceder a los componentes en el esquematico
17.       printf("Nombre: %s\n", P.name);
18.  // toma los nombres de las partes existentes
19.       printf("Valor: %s\n", P.value);
20.  // toma los valores de las partes existentes
21.         }
22. }
23.       dlgMessageBox("Busca en el directorio del eagle, el archivo ejemplo3.txt");
24. // muestra en una ventana de dialogo
25. }

El ejemplo 3 difiere de los ejemplo anteriores en que los nombres y valores de los componentes hallados se guardaran en un archivo.

al ejecutar el ULP:




Si buscamos el archivo en el directorio del Eagle (por defecto):



Allí se observa que aparecen los nombres y valores de los componentes.

Ejemplo 4:

Código: C

1. #usage "<b>Ejemplo4</b>\n"
2.        "<p>"
3.        "Mediante la Directiva <b>#usage</b>, podemos colocar "
4.        "la descripcion de la ULP"
5.        "<p>"
6.        "<author>Autor: mail@mail.com"
7. ///////////////////////////////////////////////////////////////////////    
8. if(schematic){
9. // si estamos en la ventana schematic, se ejecutara esta estructura.
10. string coordenadas, todo;
11. // declaracion de variables
12.     schematic(SCH) {   
13.        SCH.sheets(SH) {
14. // entra al miembro sheets
15.           SH.nets(N) {
16. // entra al miembro nets (es un miembro loop, o lazo)
17.              N.segments(SEG) {
18. //entra al miembro segments (es un miembro loop, o lazo)
19.         SEG.junctions(P) {
20. //entra al miembro junctions (es un miembro loop, o lazo)
21.                   sprintf(coordenadas,"Se hallo una union en: (%0.1f, %0.1f) mm\n",u2mm(P.x),u2mm(P.y));
22. //esta sentencia tomara las coordenadas de todas las uniones
23. //(los miembros x e y) en milimetros y la guardara en
24. //coordenadas como string
25.         todo+=coordenadas;
26. // concatenacion de cadenas, equivale a todo=todo+coordenadas
27.          }
28.               }
29.            }
30.         }
31.       dlgMessageBox(todo); //muestra en ventana toda la cadena
32.     }
33. }
34.  
35. //////////////////////////////////////////////////////////////////////
36. if(board){     
37. // si estamos en la ventana board, se ejecutara esta estructura.
38.    board(variable2){    //miembro de datos
39.    string grilla;
40.    sprintf(grilla,"El Size actual del Board es: %f mil\n", variable2.grid.distance);
41. // llama al miembro de datos distance y lo guarda en la cadena grilla
42.    dlgMessageBox(grilla);
43. // muestra en ventana el contenido de grilla
44.    }
45. }

En el ejemplo4 se vá un poquito mas allá y se vé la directiva #usage que le indica al Eagle mostrar la información del ULP en el panel de control.



- Dependiendo de donde nos encontremos(schematics o board) la ulp ejecutará estructuras diferentes.

- Estando en el esquematico, para obtener las coordenadas de las uniones, tenemos que llegar al miembro junctions(x e Y) que se encuentra anidando a sheets-nets-segments.

al ejecutar el ULP (en el esquematico):



se observa que muestra en ventana todas las uniones halladas en el esquematico.

- Ahora, ejecutando el ULP en el board:



allí se observa que muestra el valor de la grilla en mil.


A medida que vaya sacando mas ULP, las iré publicando con sus respectivas explicación. En verdad se pueden hacer muchas cosas (y mas rapidas) usando esta herramienta.

Los adjuntos los pueden descargar de aquí:

hxxp://www.4shared.com/dir/596842/82e6c8c9/ULP.html

Salu2

[Nocturno]

Muy interesante y didáctico este hilo que has inaugurado, Palitroquez, lo seguiré de cerca. Muchas gracias por currártelo con tanto detalle.

[PalitroqueZ]

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:

Código: C

1. board(B){
2. ....
3. ...
4. }

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:

Código: C

1. if (board)  // pregunta si estamos en el board
2.         board(B){ //ejecuta el codigo principal
3.                 ...
4.                 ...
5.         }
6. else{   // no estamos en el board :((
7.         dlgMessageBox(": Error:\n\n Debes correr esta ULP en el board !\n");
8.         exit(0);
9. }

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:

Código: C

1. 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()

Código: C

1. output(fileName) {
2.         printf(....);
3.         ....
4.   }

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)

Código: C

1. B.rectangles(REC) { // revisa todos los rectangulos
2.         printf("LAYER %d;\n", REC.layer); //identifica en que capas esta el rectangulo
3.         printf("RECT (%5.3f %5.3f) (%5.3f %5.3f);\n", u2mil(REC.x1), u2mil(REC.y1),
4.         u2mil(REC.x2), u2mil(REC.y2));
5.                 // crea el nuevo rectangulo según la capa
6. }

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:
 

Código: C

1. printf("GRID MIL 50\n");

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:

Código: C

1. GRID MIL 50
2.   LAYER 1;
3.   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

Código: C

1. B.elements(E) {
2.    //aqui va todos los miembros que pertenezcan a elements
3.   }

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:

Código: C

1. 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:

Código: C

1. if(E.angle==90)
2.    printf("rotate (%5.0f %5.0f)\n",u2mil(E.x),u2mil(E.y));
3.   else
4.     if(E.angle==180){
5.        printf("rotate (%5.0f %5.0f)\n",u2mil(E.x),u2mil(E.y));
6.        printf("rotate (%5.0f %5.0f)\n",u2mil(E.x),u2mil(E.y));
7.     }
8.     else
9.        if(E.angle==270){
10.          printf("rotate (%5.0f %5.0f)\n",u2mil(E.x),u2mil(E.y));
11.          printf("rotate (%5.0f %5.0f)\n",u2mil(E.x),u2mil(E.y));
12.          printf("rotate (%5.0f %5.0f)\n",u2mil(E.x),u2mil(E.y));
13.        }

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.

Código: C

1. B.signals(S){
2.    S.wires(W) {
3.      printf("layer %d\n",W.layer);
4.      printf("wire '%s' %d %3.0f (%5.3f %5.3f) (%5.3f %5.3f)\n",
5.      S.name, W.layer, u2mil(W.width),u2mil(W.x1),u2mil(W.y1),
6.      u2mil(W.x2),u2mil(W.y2));
7.    }
8.        
9.    S.vias(V){
10.      printf("via '%s' round  %5.3f ( %5.3f %5.3f)\n",
11.      S.name,u2mil(V.diameter[1]),u2mil(V.x),u2mil(V.y));
12.     }

El rectangulo blanco que siempre bordea el layout, que no es mas   que un wire, se puede generar:

Código: C

1. B.wires(WIR){ // es para el wire (layer20 dimension) el rectangulo blanco
2.        printf("LAYER %d\n", WIR.layer);
3.        printf("WIRE %5.3f (%5.3f %5.3f) (%5.3f %5.3f);\n", u2mil(WIR.width),
4.        u2mi(WIR.x1), u2mil(WIR.y1), u2mil(WIR.x2), u2mil(WIR.y2));
5.     }

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.

Código: C

1. B.holes(huecos){
2.     printf("CHANGE DRILL %d\n",u2mil(huecos.drill));
3.  }

finalmente para restaurar los valores iniciales del board colocamos los siguientes comandos:

Código: C

1. printf("RATSNEST\n");   //
2.    printf("GRID LAST\n");       // restaura el sistema de unidades anterior
3.    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

[jfh900]

Muy buen hilo. Adelante con el tema, es muy interesante.

Un saludo

[Nocturno]

Esta ULP es muy interesante, sobre todo cuando se pierde el vínculo entre esquemático y board. Hay un post por ahí de un usuario que no podía recuperarlo de ninguna manera y la única solución era dibujar el board entero otra vez.

[jfh900]

Ya nos falta menos para pasar las PCB'S del Proteus al Ares 

Un saludo

[PalitroqueZ]

¿Que Tal Foreros?. Estoy revisando unas ULP del directorio Eagle, Tengo una duda respecto a una traducción porque siempre me consigo con estas palabra: Snap y el babylon me dice: Chasquido, chasquear y con mi pobre inglés deduzco que significa algo así como fijar ó activar, por ejemplo: snap wires no le encuentro el significado. ¿Alguien lo podría traducir?

Salu2

[PalitroqueZ]

Hola foreros. El siguiente tema a tratar son los poligonos, y en este caso será los que usamos como señales electricas, o sea, los que usamos como plano gnd en nuestros layouts, el código servirá para copiar los planos hechos a base de poligonos, para entender como funciona este código (tomado del ULP "export-board.ulp"), vamos a partir desde lo mas sencillo, para ello nos vamos al board en el eagle y dibujamos un poligono



allí vemos que está formado por 3 puntos, en la escala de MIL,

pto1=(0 0)
pto2=(300 400)
pto3=(350 200)

bien! este poligono que se hizo a mano, tambien se puede realizar mediante un script,usando el comando POLY, cuyos parametros básicos son: nombre del poligono, capa y coordenadas, si quisieramos hacer el mismo poligono de la imagen anterior, usariamos:

POLY 'mi_poligono' 16.000 (0.000 0.000) (300.000 400.000) (350.000 200.000) (0.000 0.000)

el 16.000 se refiere a la capa BOTTOM, allí tenemos 4 coordenadas, quiere decir que vamos generando las lineas desde un punto al siguiente y al final regresamos al punto inicial

una observación: los poligonos tienen 2 formas de trazo, la linea directa y los arcos, y ello vendrá definido por el comando:

SET WIRE_BEND



así que dependiendo del valor de n, El ULP copiará y generará el poligono correspondiente (para la mayoría de los casos n=2 linea directa entre punto y punto)



Bueno ya sabemos como crear poligonos, vamos hacer eso mismo mediante programación,
si vemos en la ayuda del eagle:



tomaremos este porque el otro que aparece mas arriba, se usa sin conexiones electricas

Para dibujar poligonos, usaremos el miembo de lazo contours()

allí va nuestro primer codigo:

Código: C

1. board(G){
2. string coordenadas,result;
3. int contador=0;
4.  
5.         G.signals(B){
6.                 B.polygons(POL) {
7.                         POL.contours(CON) {
8.                         contador++;
9.                         sprintf(coordenadas, "punto %d: (%5.3f %5.3f)
10.                         (%5.3f  %5.3f)\n",contador,u2mil(CON.x1),u2mil(CON.y1),                                                 u2mil(CON.x2), u2mil(CON.y2));
11.                         dlgMessageBox(coordenadas);
12.         }}}}

contours() es miembro de de polygons que a su vez es miembro de signal y sus miembros de datos (algo así como sus propidades) son las mismas de Wire



con este código averiguaremos como trabaja contours(), y al probarlo con nuestro poligono previamente diseñado:







allí vemos los tres puntos generados por el código, y que vienen siendo:



en el comando POLY necesitamos 4 coordenadas, y comparando este resultado, vemos que hay 6 coordenadas, se repiten pues, 2 coordenadas que son:



si comparamos la tabla anterior, quitando esas 2 coordenadas nos quedaran, las que necesitamos y que fué las que usamos al principio con el comando POLY

Hay varias formas de hacerlo, tanto en la ayuda el eagle como en "export-board.ulp" muestran una, y es usando una bandera (así como en ensamblador), que en caso de valer 1 ó 0 ejecutará condiciones distintas. Nosotros necesitamos por lo menos la primera linea (ver la tabla en linea 1) y de ahí en adelante eliminar de los puntos X1 e Y1, sustituyendo por las lineas X2 e Y2, aquí vá el código:

Código: C

1. B.polygons(POL) {
2.         printf("SET WIRE_BEND 2;\n");    /* Este comando permite el trazado de poligono en linea recta*/
3.         printf("LAYER %d\n", POL.layer);
4.         printf("POLY '%s' %5.3f ", B.name, u2mil(POL.width));
5.         int first = 1;
6.         POL.contours(CON) {
7.           if (first) {//toma el primer punto
8.             printf("(%5.3f %5.3f) (%5.3f %5.3f)", u2mil(CON.x1), u2mil(CON.y1), u2mil(CON.x2), u2mil(CON.y2));
9.             first = 0;
10.         dlgMessageBox("estoy dentro del iF");
11.           }
12.           else {//toma el resto de los puntos
13.             printf(" (%5.3f %5.3f)", u2mil(CON.x2), u2mil(CON.y2));
14. dlgMessageBox("estoy en el else");
15.           }
16.         }
17.         printf(";\n"); // siguiente linea y repite el ciclo si hay mas poligonos

En las imagenes se observa que efectivamente salen las coordenadas que queremos. Entonces este algoritmo nos sirve para copiar los poligonos en un layout, debemos arreglarlo un poco para que pueda guardar el script en un archivo, allí vá el código funcionando:

Código: C

1. if (board)
2. board(G) {
3.    // Get filename
4.   string fileName = dlgFileSave("Save File", filesetext(G.name, ".scr"), "*.scr");
5.   if (fileName == "") exit(0);  //comprueba si se creó el archivo
6.  
7.   output(fileName) {
8.   printf("GRID MIL 50\n");  //AÑADIDO
9.   printf("RATSNEST\n");         // para refrescar y actualizar el board
10.  
11.         G.signals(B) { /* debemos identificar las señales del poligono*/           printf("SIGNAL '%s'", B.name);         B.contactrefs(CON) {
12.           printf(" %s %s", CON.element.name, CON.contact.name);
13.         }        printf(";\n");             /*/////////////////////////////////*/       B.polygons(POL) {
14.         printf("SET WIRE_BEND 2;\n");    /* Este comando permite el trazado de poligono en linea recta*/
15.         printf("LAYER %d\n", POL.layer);
16.         printf("POLY '%s' %5.3f ", B.name, u2mil(POL.width));         int first = 1;
17.         POL.contours(CON) {
18.           if (first) {
19.             printf("(%5.3f %5.3f) (%5.3f %5.3f)", u2mil(CON.x1), u2mil(CON.y1), u2mil(CON.x2), u2mil(CON.y2));
20.             first = 0;
21.           }
22.           else {
23.             printf(" (%5.3f %5.3f)", u2mil(CON.x2), u2mil(CON.y2));
24.           }
25.         }
26.         printf(";\n");
27.       }
28. }
29. ////////////////////////////////////////         
30.    printf("RATSNEST\n");
31.    printf("GRID LAST\n");       //AÑADIDO
32.    printf("Window Fit\n");      //AÑADIDO
33.   }
34. }
35.  
36. else {
37.    dlgMessageBox(": Error:\n\n ¡ Debes correr esta ULP en el board !\n");
38.    exit (0);
39. }

si usamos el mismo board , con este ULP, se generará un script, y al revisarlo, veremos

Código: C

1. GRID MIL 50
2. RATSNEST
3. SIGNAL 'S$1';
4. SET WIRE_BEND 2;
5. LAYER 16
6. POLY 'S$1' 16.000 (0.000 0.000) (300.000 400.000) (350.000 200.000) (0.000 0.000);
7. RATSNEST
8. GRID LAST
9. Window Fit

este será el script para generar nuestro poligono, si hubiera mas poligonos se repite el miembro contours() y en su capa correspondiente

Pero ese ULP así como está no nos servirá de mucho, falta añadirlo a la ULP "copiar_layout2.ulp" que es el ULP que hemos estado manejando en este post y ya que se va añadir este código habrá que complementar con estas lineas:

Código: C

1. printf("CHANGE ISOLATE %5.3f (%5.3f %5.3f);\n", u2mil(POL.isolate),
2.           u2mil(x0), u2mil(y0));

Esta linea ajusta la separación ó aislación entre el plano y el resto de los objetos que no contienen el mismo nombre del poligono



las flechas de color amarillo indican la separación del plano ó poligono con el resto, que en el eagle se define con el comando ISOLATE, para que funcione correctamente hay que indicarle las coordenadas de partida del poligono. Esto se hace declarando las variables x0 e y0,que son las coordenadas del poligono cuando la bandera first=1 (el punto de inicio del poligono) y se colocaran esta linea dentro de loop member contours()

Código: C

1. x0 = CON.x1;    // toma las coordenadas del poligono
2.               y0 = CON.y1;

Todo está en ulp_capitulo3.rar que pueden bajar de:

hxxp://www.4shared.com/dir/596842/82e6c8c9/ULP.html

Nota: como se mencionó anteriormente el copiar el plano gnd tiene sus limitaciones, por ejemplo si tenemos un plano con arcos, al reproducir en un nuevo board, se sustituirá por lineas directas, esto es debido a que se agregó "SET WIRE_BEND 2", pero esto no debería presentar problemas, ya que en la mayoría de las aplicaciones los poligonos se dibujan con rectas.

Salu2

[JpSID]

Hola PalitroqueZ, muchisimas gracias por esta ayuda .
Sabes, estaba a punto de comenzar a routear te nuevo mi placa (despues de varios dias y noches de duro trabajo y empeño  ), nose que paso que me fallo unas conexiones, borre unos componentes y los reemplaze por otros, creo que ahi fue cuando perdio la sincronizacion  el .sch con .brd (que raro  ), pero con la ulp que hiciste (copiar_layout.ulp ), pude salvar mi trabajo  , nuevamente muchas gracias .

pd. tambien muchas gracias a Nocturno que dirrecciono aca, en un comentario que dijo en otro lado.

[Nocturno]

Pues no sé de qué comentario se trata, pero en cualquier caso, no hay de qué 

[JpSID]

Hola Nocturno, me presento, soy JpSID, mucho gusto ^-^  .

Jejeje creo que se me olvido poner las dirección donde encontre el enlace hacia aca xD,  aca lo pongo : solucionar inconsistencias en eagle

[Marttyn]

Hola Pali!
Muy interesante esto de las ULP. Ahora estaba pensando en crear una que me genere el gcode de los taladros de manera sencilla...
Leere todo con detenimiento y a ver si lo consigo!
Salu2

[baena90]

Hola PalitroqueZ, muchisimas gracias por esta ayuda .
Sabes, estaba a punto de comenzar a routear te nuevo mi placa (despues de varios dias y noches de duro trabajo y empeño  ), nose que paso que me fallo unas conexiones, borre unos componentes y los reemplaze por otros, creo que ahi fue cuando perdio la sincronizacion  el .sch con .brd (que raro  ), pero con la ulp que hiciste (copiar_layout.ulp ), pude salvar mi trabajo  , nuevamente muchas gracias .

pd. tambien muchas gracias a Nocturno que dirrecciono aca, en un comentario que dijo en otro lado.

buenas tardes ejecuto el upl y me sale un error en el printf espero me puedas ayudar

[baena90]

buenas tardes

utilizo el upl pero me marca ese error espero me puedas colaborar