Arquitectura, Diseño y CAD

Rutina cuenta bloques iguales de una misma capa

2009-06-23T12:45:00.000-07:00

;|comando "blcont" cuenta bloques iguales a uno señalado
siempre que estén en la misma capa indicada.
****Prexem - 2009****
********************************************************|;
(defun C:blcont (/ cmdechant nomb lista cant)
(setq cmdechant (getvar "cmdecho"))
(setvar "cmdecho" 0)
(vl-load-com)
(setq ent (car (entsel "\nseleccione bloque a contar: ")))
(setq vle (vlax-ename->vla-object ent))
(setq nomb (vlax-get vle "name"))
(setq cap (vlax-get vle "layer"))
(setq
lista (ssget "_x"
(list (cons 0 "INSERT") (cons 2 nomb) (cons 8 cap))
)
)
(setq cant (sslength lista))
(princ
(strcat "\nCantidad de bloques con nombre " nomb ": ")
)
(princ cant)
(setvar "cmdecho" cmdechant)
(princ)
);;;fin

Rutina "long-tramos" obtiene las longitudes de los tramos de una polilínea indicada:

2008-07-07T02:26:00.000-07:00


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; by  (c) Prexem - Victor Adolfo Bracamonte - 2008 ;;;
;;;             www.prexem.blogspot.com              ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun c:long-tramos (/ errant *error*   e vla-e
        long i    f  v    c    cant
        xp   c1 yp   zp   p
        lp   rlp  cantp    p1
        p2   d
       )
  (vl-load-com)
  (defun errlongtramos (m) (prompt "\n*fin*"))
  (setq errant *error*
 *error* errlongtramos
  )
  (setq e
  (car
    (entsel
      "\nseleccione polilinea a medir tramos:"
      )
    )
 )
  (if
    (or
     (equal (cdr (assoc 0 (entget e))) "POLYLINE")
     (equal (cdr (assoc 0 (entget e))) "LWPOLYLINE")
    )
  (progn
  (setq
    vla-e (vlax-ename->vla-object e)
    long  (vlax-get vla-e 'length)
       v  (vlax-get vla-e 'coordinates)
  )
  (princ "\nLongitud total: ")
  (princ long)
  (setq c 0)
  (setq cant (/ (length v) 2))
  (repeat cant
    (setq xp (nth c v)
   c1 (1+ c)
   yp (nth c1 v)
   zp 0.0
   p  (list xp yp zp)
   lp (cons p lp)
   c  (1+ c1)
    )
  )
  (setq rlp (reverse lp))
  (setq cantp (length rlp))
  (setq c 0)
  (repeat cantp
    (setq p1 (nth c rlp))
    (setq c1 (1+ c))
    (setq p2 (nth c1 rlp))
    (setq d (distance p1 p2))
    (setq c (1+ c))
    (princ "\ntramo ")
    (princ c1)
    (princ ": ")
    (princ d)
  )
  )
    (princ "\n*EL OBJETO INDICADO NO ES POLILINEA*")
    )
  (setq *error* errant)
  (princ)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Rutina "STN" sirve para sumar grupos de textos numéricos:

2008-06-21T16:26:00.000-07:00


;|***********************************************
     rutina "stn" suma textos numericos,
     funciona con TEXT y MTEXT no editados 
     (No formateados).
  ***********************************************
  (c) by Prexem - Victor Adolfo Bracamonte - 2008
  ****       www.prexem.blogspot.com         ****
  ***********************************************|;
(defun c:stn (/ sel p h cant index e data val n listn sum res)
  (prompt
 "\nSeleccione textos numericos a sumar, que no hayan sido editados:"
  )
  (setq sel   (ssget '((0 . "MTEXT,TEXT")))
 p     (getpoint
  "\nDar punto de inserción para texto final:"
  )
 h     (getdist p "\nDar altura de texto:")
 cant  (sslength sel)
 index 0
  );setq
  (repeat cant
    (setq e (ssname sel index)
   data  (entget e)
   val   (cdr (assoc 1 data))
   n (atof val)
   listn (cons n listn)
   index (1+ index)
    );setq
  );repeat
  (setq sum (apply '+ listn))
  (setq res (rtos sum 2 2))
  (command "_.text" p h 0 res)
  (princ)
);defun
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Rutina que sirve para cerrar grupos de polilíneas abiertas.

2008-06-14T18:02:00.000-07:00


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun c:close-plines (/ sel cant index obj origen final)
  (vl-load-com)
  (prompt "****\nSeleccione polilineas a cerrar\n****")
  (setq sel (ssget '((0 . "*POLYLINE")))
 cant (sslength sel)
 index 0
 )
      (repeat cant
 (setq obj (ssname sel index))
  (setq origen (vlax-curve-getstartpoint obj)
        final  (vlax-curve-getendpoint obj)
  )
  (if (equal origen final 0.001)
    (alert "Pline cerrada....")
    (command "_pedit" obj "_c" "")
  );if
 (setq index (1+ index))
      );repeat
  (princ)
);fin
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Rutina que sirve para obtener el volumen y centroide de un sólido 3d:

2008-06-11T02:53:00.000-07:00


;|    rutina "vol_solid" sirve para medir
      volumen de un solido seleccionado.
      ****************************************
      (c)by Prexem - Victor Adolfo Bracamonte*
      WWW.Prexem.BlogSpot.Com
      ****************************************|;
(defun c:vol_solid (/ sol vsol vol centr)
  (vl-load-com)
  (setq sol(car(entsel "\nseleccione un solido:"))
 vsol (vlax-ename->vla-object sol)
        vol (vlax-get vsol 'volume)
 centr (vlax-get vsol 'centroid)
 );setq
  (princ "\ncentroide del solido: ")(princ centr)
  (princ "\nvolumen del solido: ")(princ vol)
  (princ)
  );defun

Rutina para medir el ángulo entre dos rectas, sean líneas o polilíneas:

2008-06-09T22:54:00.000-07:00


;|    rutina "ang_entre_pl" sirve para medir
      el angulo existente entre dos lineas
      o polilineas rectas indicandolas.
      ****************************************
      (c)by Prexem - Victor Adolfo Bracamonte*
      WWW.Prexem.BlogSpot.Com
      ****************************************|;
(defun c:ang_entre_pl (/ pl1 vpl1 in1 fin1 ang1 pl2 vpl2
         in2 fin2 ang2 angmax angmin
         ang_entr ang_grad)
  (vl-load-com)
  (setq pl1(car(entsel "\nseleccione polilinea recta 1:"))
 vpl1 (vlax-ename->vla-object pl1)
 in1 (vlax-curve-getstartpoint vpl1)
 fin1 (vlax-curve-getendpoint vpl1)
 ang1 (angle in1 fin1)
 pl2(car(entsel "\nseleccione polilinea recta 2:"))
 vpl2 (vlax-ename->vla-object pl2)
 in2 (vlax-curve-getstartpoint vpl2)
 fin2 (vlax-curve-getendpoint vpl2)
 ang2 (angle in2 fin2)
 angmax (max ang1 ang2)
 angmin (min ang1 ang2)
 ang_entr (- angmax angmin)
 ang_grad(* (/ ang_entr (* 2 PI)) 360)
 );setq
  (princ "\nAngulo entre lineas: ")(princ ang_grad)
  (princ)
  );defun

*Buscador de detalles para Arquitectos e Ingenieros, en archivos de productos AutoDesk, CAD, Office y otros:

2008-05-29T21:47:00.000-07:00

Nuevo servicio de AutoDesk, buscador en inglés de detalles constructivos, en formatos
*.Dwg, *.Dwf, *.Pdf, y otros, por ahora de marcas de habla inglesa:
****www.seek.autodesk.com****

Usar la barra de estado de AutoCAD para mostrar datos, con _MODEMACRO:

2008-05-11T10:05:00.000-07:00

Customizar la barra de estado de AutoCAD en DIESEL:

¿Qué es DIESEL?:

DIESEL (Direct Interpretively Evaluated String Expression Language),
es Lenguaje de Expresiones como Cadenas de Texto Interpretables en forma Directa……..
Es otra Interface de Programación de AutoCAD, sirve para personalizar la “Barra de estado”
(Status Bar) de AutoCAD, crear comandos a partir de iconos y para modificar acciones
en comandos existentes, aunque existen interfaces mas poderosas como Vlisp,
VBA u ObjectARX (C++).
Las listas en DIESEL son siempre cadenas de texto de un solo renglón, evaluables
directamente, aunque sean operaciones matemáticas,y devuelven cadenas de texto
como resultados……..Existen dos tipos de uso difundidos para el lenguaje DIESEL dentro del
AutoCAD, customizar la barra de estado y crear o modificar macros de comandos.

Personalizar resultados en “Barra de estado” con MODEMACRO:

Se suele utilizar el lenguaje DIESEL dentro de la variable de sistema MODEMACRO
para mostrar en la barra de estado cierta información como la fecha y la hora, valores
de variables de sistema o variables de entorno o valores recuperables por rutinas Vlisp.
*Aquí Las listas comienzan con signo de dólar “$”, y listas anidadas igual.
Expresiones que pueden tener este formato:

$(funcion,operando,operando)

Los resultados son igualmente cadenas de texto.
Los operandos de una expresión DIESEL van separados por comas “,”……..
*El separador de decimales es el punto “.”
*Todo parentesis de apertura tiene su par de cierre.
*Se llama al comando MODEMACRO, y allí se introduce la lista DIESEL.
* “MODEMACRO” solo sirve para usar la “barra de estado” como panel de
resultados para mostrar alguna función o variable de AutoCAD.
El valor inicial de MODEMACRO al arrancar AutoCAD es “NIL”, y vuelve a NIL
al apagar AutoCAD o al ingresar un punto “.” en la solicitud del comando.

Ejemplo:
Quiero que la Barra de Estado de AutoCAD me muestre la fecha, entonces
inicio comando “MODEMACRO” e ingreso la expresión DIESEL:

$(edtime,$(getvar,date),Es----DDDD-----DD/MONTH/YYYY)

Donde uso dos funciones DIESEL:
edtime-------devuelve fecha y hora en un formato dado.
getvar--------devuelve el valor de la variable “date” o fecha de AutoCAD.
*Aquí “edtime” toma el valor de “date” en formato decimal y lo presenta con
el formato especificado:
“ES----DDDD(Domingo)----DD(13)/MONTH(Abril)/YYYY(2008)"
Y la barra de estado queda así:

*Si quiero que también me aparezca la hora con minutos y segundos pongo
en “modemacro”:

$(edtime,$(getvar,date),Es----DDDD-----DD/MONTH/YYYY-----HH:MM:SS)

Expresión para modemacro que muestra en barra de estado la altura
presente de texto:

altura de texto:$(getvar,textsize)

*En Modemacro, todo lo que sigue al signo de dólar “$” y al paréntesis de
apertura es tomable como DIESEL, hasta que cierre ese paréntesis.

Expresión para tener el nombre del archivo actual:

$(getvar,dwgname)

Expresión que escribe en barra de estado la capa actual:

Capa actual: $(getvar,clayer)

Para que muestre capa y color actuales:

capa:$(getvar,clayer) - color:$(getvar,cecolor)

Para que aparezca el nombre del comando en ejecución:

$(getvar,cmdnames)

Mostrar area de última medición cuando este aplicando comando _area:

$(if,$(eq,$(getvar,cmdnames),AREA), area anterior:$(getvar,area))

Funciones DIESEL usables para “MODEMACRO”:

Suma----“$(+,num,num,….)”-------
Ejemplo: $(+,12,1,23.3)------es 12+1+23.3

Resta----“$(-,num,num)”-------
Ejemplo: $(-,76.2,12)---------es 76.2 – 12

Multiplicación----“$(*,num,num)”----
Ejemplo: $(*,23,2.2)----es 23 x 2.2

División----“$(/,num,num)”----
Ejemplo: $(/,211,3)-------------es 211 ÷ 3

Igualdad----“$(=,num,num)”---
Ejemplo: $(=,12,12)------------es 12=12

Menor que----“$(<,num,num)”------
Ejemplo: $(<,13.2,15)----------es 13.2 menor que 15 Mayor que----“$(>,num,num)”------
Ejemplo: $(>,87.231,76)-------es 87.231 mayor que 76

Distinto que----“$(!=,num,num)”----
Ejemplo: $(!=,64,63.89)--------es 64 ≠ 63.89

Menor o igual que----“$(<=,num,num)” ----
Ejemplo: $(<=,A,2.111)-----es A<=2.111-----A puede ser otra lista anidada.

Mayor o igual que----“$(>=,num,num)”----
Ejemplo: $(>=,B,T)-----es B>=T

Conjunción Y (algo y otra cosa)----“$(and,num,num)” ----
Ejemplo: $(and,A,B)----es A y B

Transformar un número a un ángulo en un determinado modo, como cadena de texto:
Forma: “$(angtos,num,modo,precision)”

En ANGTOS, el modo puede ser:
0 --------Grados
1 --------Grados/minutos/segundos
2 --------Grados centesimales
3 --------Radianes
4 --------Unidades de topografia

Precisión es cantidad de decimales o unidades adicionales a las cifras finales.

Ejemplo:

$(angtos,23.12,1,2) -----devuelve 244d41'

*El comando _MACROTRACE muestra en linea de comandos las trayectorias
de operaciones de comandos cuando esta en 1, en 0 queda anulada esa
muestra*
Para ver la operatoria en ventana de comandos, pongo “MACROTRACE” en 1:

Para:

$(angtos,12.22,1,4)

Macrotrace muestra esto:

Comando:

MODEMACRO

Indique nuevo valor para MODEMACRO, o . para ninguno <"">: $(angtos,12.22,1,4)

Eval: $(ANGTOS, 12.22, 1, 4)

===> 340d9'16"

Para: $(angtos,3.14,0,3) -------------macrotrace muestra:

Comando:

MODEMACRO

Indique nuevo valor para MODEMACRO, o . para ninguno <"">: $(angtos,3.14,0,3)

Eval: $(ANGTOS, 3.14, 0, 3)

===> 179.909

*Pasa un número tomado como radianes a grados sexagesimales.

Mostrar Fecha y Hora:

“$(edtime, $(getvar,date), DD/ M/ YY - H:M:SS)”

Es presentar datos de la variable “date” en un determinado formato.

*Valores de FORMATO :

D.............dia, aparece asi: 9
DD..........dia,aparece: 09
DDD............nombre de dia tres letras: lun
DDDD.........nombre completo del dia: lunes
M.............mes: 6
MO...........mes con dos cifras: 06
MON.........mes tres letras: jun
MONTH.........mes, nombre completo: junio
YY..................año dos cifras: 78
YYYY.............año cuatro cifras: 1978
H ........................hora una cifra: 8
HH.................hora dos digitos: 08
MM................minutos dos digitos: 28
SS.................segundos dos digitos: 56
AM/PM.........AM o PM mayusculas: PM
am/pm............am o pm minusculas: pm

Ejemplo:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(EDTIME, $(getvar,date), DD/ M/ YY - H:M:SS)
Eval: $(EDTIME, $(getvar,date), DD/ M/ YY - H:M:SS)
Eval: $(GETVAR, date)
===> 2454571.99886917
===> 14/ 4/ 08 - 23:4:22------lo que se verá en barra de estado.

Igualdad entre cadenas comparadas:
Forma: “$(eq,num,num)”
Ejemplo:$(eq,$(getvar,PERIMETER), 2447.11)
es:
Comando: MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(eq,$(getvar,PERIMETER), 2447.11)
Eval: $(EQ, $(getvar,PERIMETER), 2447.11)
Eval: $(GETVAR, PERIMETER)
===> 2447.11484019
===> 0-----------------la igualdad exacta no se cumple por lo que da cero,
si se cumple da 1.

Caso en que se cumple la igualdad:
$(eq,$(fix,$(getvar,PERIMETER)),1993)
Evaluacion:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(eq,$(fix,$(getvar,PERIMETER)),1993)
Eval: $(EQ, $(fix,$(getvar,PERIMETER)), 1993)
Eval: $(FIX, $(getvar,PERIMETER))
Eval: $(GETVAR, PERIMETER)
===> 1993.42587247
===> 1993
===> 1

Evaluar una cadena cualquiera:
Forma: “$(eval,expresión DIESEL)”
Ejemplo: $(eval, $(/, 12,2.3))
es:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(eval, $(/, 12,2.3))
Eval: $(EVAL, $(/, 12,2.3))
Eval: $(/, 12, 2.3)
===> 5.2173913

Otro ejemplo, mostrar la mitad del area medida anteriormente:
mitad de area:$(eval,$(/,$(getvar,AREA),2))
es:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">: mitad de
area:$(eval,$(/,$(getvar,AREA),2))
Eval: $(EVAL, $(/,$(getvar,AREA),2))
Eval: $(/, $(getvar,AREA), 2)
Eval: $(GETVAR, AREA)
===> 374271.29667677
===> 187135.64833839
aparece en linea de estado:
mitad de area: 187135.64833839

Rescatar solo la parte entera de un número real:
Forma: “$(fix,numero real)”
Mostrar redondeado el ultimo perimetro medido:
$(fix,$(getvar,PERIMETER))metros

Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
redondeando, el ultimo perimetro tenia:$(fix,$(getvar,PERIMETER))metros
Eval: $(FIX, $(getvar,PERIMETER))
Eval: $(GETVAR, PERIMETER)
===> 2447.11484019
===> 2447
en barra de estado dirá:
redondeando, el ultimo perimetro tenia: 2447metros

Obtener un valor de una variable ambiental:
Forma: “$(getenv,variable ambiental)”
Sea obtener la ruta del sistema operativo:
la macro diesel es: $(GETENV, SystemRoot)
Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">: $(getenv,SystemRoot)
Eval: $(GETENV, SystemRoot)
===> C:\WINDOWS----esto aparece en linea de estado.

Obtener valor de una variable de sistema:
Forma:”$(getvar,variable de sistema)”
Sea obtener el valor de "OSMODE" actual y mostrarlo en barra de estado,
la macro DIESEL es:
$(getvar,osmode)
Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <",">: Osmode
actual:$(getvar,osmode)
Eval: $(GETVAR, osmode)
===> 4133
Aparece en linea de estado así:
Osmode actual:4133

"SI" condicional :
Forma:”$(if,condicion,valor si se cumple, valor si no se cumple)”
Ejemplo:
Sea indicar en barra de estado si estoy en espacio modelo o en espacio papel:
$(IF, $(eq,$(getvar,cvport),1), -PAPEL-, -MODELO-)
estando en espacio medelo la evaluación es:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">: $(IF,
$(eq,$(getvar,cvport),1), -PAPEL-, -MODELO-)
Eval: $(IF, $(eq,$(getvar,cvport),1), -PAPEL-, -MODELO-)
Eval: $(EQ, $(getvar,cvport), 1)
Eval: $(GETVAR, cvport)
===> 2
===> 0
===> -MODELO- es lo aparece en barra de estado

Sea poner en barra de estado un indicador de si esta o no el “MODO ORTHO”:
Macro:$(IF, $(eq,$(getvar,orthomode),0), -MODO ORTHO FUERA-)
Evaluación cuando el modo está fuera:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(if,$(eq,$(getvar,orthomode),0),-MODO ORTHO FUERA-)
Eval: $(IF, $(eq,$(getvar,orthomode),0), -MODO ORTHO FUERA-)
Eval: $(EQ, $(getvar,orthomode), 0)
Eval: $(GETVAR, orthomode)
===> 0
===> 1
===> -MODO ORTHO FUERA- esto aparece en linea de estado.

Obtener un elemento de una lista con “INDEX”:
Forma:”$(index,numero indicador, expresion que da una lista)”
.....el numero indicador es 0 para el primer lugar, y 9 para el ultimo.

Sea mostrar las tres coordenadas del último punto al terminar un comando:
macro:
$(INDEX, 0, $(getvar,LASTPOINT)), $(INDEX, 1, $(getvar,LASTPOINT)), $(INDEX, 2, $(getvar,LASTPOINT))
Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">: $(INDEX, 0,
$(getvar,LASTPOINT)),$(INDEX, 1, $(getvar,LASTPOINT)),$(INDEX, 2,
$(getvar,LASTPOINT))
Eval: $(INDEX, 0, $(getvar,LASTPOINT))
Eval: $(GETVAR, LASTPOINT)
===> 2982.40238032,672.8905039,0
===> 2982.40238032
Eval: $(INDEX, 1, $(getvar,LASTPOINT))
Eval: $(GETVAR, LASTPOINT)
===> 2982.40238032,672.8905039,0
===> 672.8905039
Eval: $(INDEX, 2, $(getvar,LASTPOINT))
Eval: $(GETVAR, LASTPOINT)
===> 2982.40238032,672.8905039,0
===> 0
aparece en barra de estado:
2982.40238032, 672.8905039,0

Evaluar selectivamente algún argumento de una expresión con “NTH”:
sea la siguiente expresión condicional aplicada a una distancia tomada
previamente con el comando “_DIST”,es------si la distancia tomada, es menor
o igual a 1200.0, evalua la primera expresion de dos dadas, sino evalua la
segunda de dos dadas:
$(if,$(<=,$(getvar,DISTANCE),1200.0),$(nth,0,$(/,$(getvar,DISTANCE),2),0.0), $(nth,1,$(/,$(getvar,DISTANCE),2),$(/,$(getvar,DISTANCE),3))) Evaluación con MODEMACRO:
Comando: MODEMACRO Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(if,$(<=,$(getvar,DISTANCE),1200.0),$(nth,0,$(/,$(getvar,DISTANCE),2),0.0),
$(nth,1,$(/,$(getvar,DISTANCE),2),$(/,$(getvar,DISTANCE),3)))

Eval: $(IF, $(<=,$(getvar,DISTANCE),1200.0), $(nth,0,$(/,$(getvar,DISTANCE),2),0.0), $(nth,1,$(/,$(getvar,DISTANCE),2),$(/,$(getvar,DISTANCE),3)))
Eval: $(<=, $(getvar,DISTANCE), 1200.0)
Eval: $(GETVAR, DISTANCE) ===> 1377.12628071
===> 0
Eval: $(NTH, 1, $(/,$(getvar,DISTANCE),2), $(/,$(getvar,DISTANCE),3))
Eval: $(/, $(getvar,DISTANCE), 3)
Eval: $(GETVAR, DISTANCE)
===> 1377.12628071
===> 459.04209357
aparece n barra de estado: 459.04209357
Porque en ese caso $(getvar,DISTANCE) da-------1377.12628071

Optar por uno u otro, con “OR”:
Ejemplo,sea optar por un valor de medición de AREA o por valor =0:
$(or,$(getvar,AREA),0)
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(or,$(getvar,AREA),0)
Eval: $(OR, $(getvar,AREA), 0)
Eval: $(GETVAR, AREA)
===> 10000-------------opta por el valor de area, cuando existe medición previa.
Si no existe solo evalúa el valor de $(getvar,AREA), y omite evaluar el 0.

Otro ejemplo:
Opción por dos números, los suma:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">: $(or,1,2)
Eval: $(OR, 1, 2)
===> 3

Convertir un número en cadena de texto según un formato con “RTOS”:
Ejemplo:
Quiero que el valor de la última distancia medida me aparezca como cadena
de texto en modo “DECIMAL” y precisión “2”:
Expresión para MODEMACRO:
$(rtos,$(getvar,DISTANCE),2,2)
Evaluación:
Comando: modemacro
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(rtos,$(getvar,DISTANCE),2,2)
Eval: $(RTOS, $(getvar,DISTANCE), 2, 2)
Eval: $(GETVAR, DISTANCE)
===> 3346.90532671
===> 3346.91------resultado en barra de estado.
Es:
$(RTOS, valor, modo, precisión)
Los valores de modo posibles son:
1........... Científico
2 ...........Decimal
3 ...........Pies y pulgadas I (fracción decimal)
4 ...........Pies y pulgadas II (fracción propia)
5 ...........Fraccional

Medir cantidad de caracteres de una cadena de texto con “STRLEN”:
Sea mostrar en barra de estado la cantidad de caracteres de la cifra de
la última medición de distancia:
Expresión para MODEMACRO:
$(strlen,$(rtos,$(getvar,DISTANCE),2,2))
Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(strlen,$(rtos,$(getvar,DISTANCE),2,2))
Eval: $(STRLEN, $(rtos,$(getvar,DISTANCE),2,2))
Eval: $(RTOS, $(getvar,DISTANCE), 2, 2)
Eval: $(GETVAR, DISTANCE)
===> 3346.90532671
===> 3346.91
===> 7-----Esto aparece en barra de estado.

Subcadena de una cadena de texto con “SUBSTR”:
De una cifra extraigo una parte y la muestro en barra de estado........
$(SUBSTR, $(rtos,$(getvar,DISTANCE),2,2), 2, 5)
Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">: $(SUBSTR,
$(rtos,$(getvar,DISTANCE),2,2), 2, 5)
Eval: $(SUBSTR, $(rtos,$(getvar,DISTANCE),2,2), 2, 5)
Eval: $(RTOS, $(getvar,DISTANCE), 2, 2)
Eval: $(GETVAR, DISTANCE)
===> 1710.90043324
===> 1710.9
===> 1710.------esto aparece en barra de estado.

Convertir una cadena de texto a mayúsculas con “UPPER”:
$(upper,$(getvar,dwgname))
Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(upper,$(getvar,dwgname))
Eval: $(UPPER, $(getvar,dwgname))
Eval: $(GETVAR, dwgname)
===> Dibujo1.dwg
===> DIBUJO1.DWG------esto aparece en barra de estado.

“XOR”, operador lógico “O” exclusivo:

La regla de operación en “XOR” es un tipo de uso exclusivista de “OR”:
(XOR 12 13) ES = (12 OR 13) Y NUNCA (12 Y 13)
Ejemplo:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(xor,2.2,3,6,7.7,67.8)
Eval: $(XOR, 2.2, 3, 6, 7.7, 67.8)
===> 67

$(xor,$(getvar,osnapz),1)
Evaluación:
Comando:
MODEMACRO
Indique nuevo valor para MODEMACRO, o . para ninguno <"">:
$(xor,$(getvar,osnapz),1)
Eval: $(XOR, $(getvar,osnapz), 1)
Eval: $(GETVAR, osnapz)
===> 1
===> 0

..........................................................................................................

*Ejemplos de expresiones DIESEL para MODEMACRO”:

*Expresión para que se muestre en barra de estado si un comando está en progreso o si está inactivo todo:
$(IF, $(eq,$(getvar,CMDACTIVE),1), >>>>*EN PROGRESO*>>>>, ----*INACTIVO*----)

*Fecha:
$(EDTIME, $(getvar,date), DD/MM/YYYY)

*Indicar en que color salen los objetos creados:
*Los objetos creados saldrán en color: $(getvar,CECOLOR)

*Saber a que altura estarán las cámaras:
*Las camaras se ubican en altura:$(getvar,cameraheight)

*Indicar en que ventana estamos, modelo o papel:
$(IF, $(eq,$(getvar,cvport),2), *MODELO*)$(IF, $(eq,$(getvar,cvport),1), *PAPEL*)

*Mostrar status de la entrada dinámica:
$(if,$(eq,$(getvar,DYNMODE),-1),*Entrada dinamica fuera*)$(if,$(eq,$(getvar,DYNMODE),1),*Entrada de puntero activada*)$(if,$(eq,$(getvar,DYNMODE),2),*Entrada de cotas activada*)$(if,$(eq,$(getvar,DYNMODE),3),*Entrada de puntero y de cotas activadas*)

*Mostrar elevacion de objetos creados:
Elevacion de los objetos creados:$(getvar,ELEVATION)

*Mostrar puntos limites de la extensión del dibujo en espacio modelo:
Punto inferior izquierdo:$(getvar,EXTMIN) – Punto superior derecho:$(getvar,EXTMAX)

*Saber en que nivel de suavidad van saliendo los objetos modelizados:
Nivel de suavidad de objetos modelizados:$(*,10,$(getvar,facetres))%

*Ver el valor de tolerancia a huecos en contornos, cuando se ejecuta un
Sombreado:
$(if,$(eq,$(getvar,cmdnames),BHATCH),Tolerancia actual a huecos en contornos:$(getvar,HPGAPTOL))

*Datos para el caso de hacer un sombreado:
$(if,$(eq,$(getvar,cmdnames),BHATCH),Tolerancia actual a huecos en contornos:$(getvar,HPGAPTOL)-Escala del sombreado:$(getvar,HPSCALE))

*Mostrar el nombre del bloque a insertar:
$(if,$(eq,$(getvar,cmdnames),INSERT),Bloque insertado:$(getvar,INSNAME))

*Muestra el último angulo almacenado al ejecutar un comando lineal como
polilinea, linea o arco:
ULTIMO ANGULO INTRODUCIDO:$(ANGTOS,$(GETVAR,LASTANGLE),0,2)º

*Muestra la distancia focal de perspectiva:
Distancia focal actual de perspectiva: $(getvar,lenslength)

*Mostrar los datos geográficos de ubicación del sitio del modelo:
Lugar del modelo--->Latitud:$(getvar,LATITUDE)-Longitud:$(getvar,LONGITUDE)

*Un comando AutoLISP para que aparezca la hora de creación del archivo
en barra de estado:
;;;indicar hora de creacion del presente archivo
;;;en barra de estado
(defun c:hora_archiv()
(setvar "modemacro"
"El presente archivo se creo a la hora:$(EDTIME, $(getvar,tdcreate), HH:MM)"
)
(princ)
);fin

*Poner un TIMER o Cronómetro en barra de estado que indique tiempo
transcurrido desde el inicio de archivo presente:
Transcurridos:$(EDTIME, $(getvar,tdusrtimer), MM:SS)Minutos

*Nombre del sistema actual de coordenadas:
Sistema de coordenadas actual: $(getvar,UCSNAME)

*Mostrar si el archivo actual es o no de solo lectura:
$(if,$(eq,$(getvar,WRITESTAT),0),*ARCHIVO SOLO LECTURA*)$(if,$(eq,$(getvar,WRITESTAT),1),*ARCHIVO MODIFICABLE*)

*Mostrar si las unidades por defecto se inician en milimetros o no en el dibujo:
$(if,$(eq,$(getenv,InsertUnitsDefSource),4),*Unidades en mm por defecto*,*Unidad por defecto diferente de mm*)
Expresión vlisp para hacer que las unidades por defecto en los dibujos sean
metros:
(setenv "InsertUnitsDefSource" "6")

*NOTA: Todas las expresiones DIESEL a ser ingresadas por _MODEMACRO,
deben ser de una sola linea o renglon, no pueden tener saltos de linea, por ello
es aconsejable realizarlas en el block de notas en una linea y despues copiar
y pegar en linea de comandos.
..................................................................................................................................................

*Páginas para consultar sobre DIESEL:
http://www.crlf.de/Dokumente/Diesel/Diesel.html
www.fourmilab.ch/diesel
http://members.iinet.net.au/~bigbyte/diesel.htm
http://www.upfrontezine.com/tailor/tailor17.htm
http://www.kxcad.net/autodesk/autocad/AutoCAD_2008_Customization_Guide/index.left.htm
http://www.kxcad.net/autodesk/autocad/AutoCAD_2008_Customization_Guide/ws73099cc142f4875513fb5cd10c4aa30d6b-7d0a.htm
http://web.madritel.es/personales1/argalnares/13_rutinas.htm
http://www.lawebdelprogramador.com/cursos/autocad/autocad_9.php
http://www.caddigest.com/subjects/autocad/tutorials/select/parsai_building_menu5.htm
http://www.grapevine.net/~lacy/index.html
..........................................................................................................................................

ESCACLIC.LSP........Perfil de escalera de un tramo con dos clicks de ratón:

2008-04-30T17:22:00.000-07:00


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;RUTINA "ESCACLIC" HACE UN PERFIL GENERICO DE UNA ESCALERA DE UN TRAMO;;;
;;;INTRODUCIENDO PUNTO DE ARRANQUE Y PUNTO DE LLEGADA DE LA MISMA ;;;;;;;;;
;;;HACIENDO UN TANTEO DE MEDIDAS IDEALES PARA UN ESTUDIO PREVIO ;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(PRINC "\n....* ESCACLIC ** TRAMO DE ESCALERA CON DOS CLICKS DE RATON *
        ** © AUTOR: VICTOR ADOLFO BRACAMONTE....2007 **")

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(DEFUN VAR_VARESCACLIC ()
    (COMMAND "_OSMODE" 0)
     (COMMAND "_PICKBOX" 0)
);VARIAR VARIABLES DE SISTEMA EN ESCACLIC

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(DEFUN ENTRADADEDATOSESCACLIC ()
  (SETQ ARR (GETPOINT "\nDAR PUNTO DE ARRANQUE DE ESCALERA: "))
   (SETQ LLEG (GETPOINT "\nDAR PUNTO DE LLEGADA DE ESCALERA: "))
   (SETQ ALT (ABS (* (DISTANCE ARR LLEG) (SIN  (ANGLE ARR LLEG))))
        DESH (ABS (* (DISTANCE ARR LLEG) (COS  (ANGLE ARR LLEG))))
   )
   (SETQ ANGESC  (ANGLE ARR LLEG));ANGULO DE LA ESCALERA
   (IF (AND(> ANGESC 0)(< ANGESC (/ PI 2))) (SETQ DIRECCIONAL 1))
    (IF (AND(> ANGESC (/ PI 2))(< ANGESC PI)) (SETQ DIRECCIONAL 2))
            (IF(AND (> ANGESC PI)(< ANGESC (* 1.5 PI))) (SETQ DIRECCIONAL 3))
             (IF (AND (> ANGESC (* 1.5 PI)) (< ANGESC (* 2 PI)))
        (SETQ DIRECCIONAL 4)
      )
 );FIN DE ENTRADA DE DATOS
   
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(DEFUN ATRASESCACLIC ()
  (SETQ OSMESCACLIC (COMMAND "_OSMODE" 4133))
  (SETQ PICKESCACLIC (COMMAND "_PICKBOX" 3))
)
(DEFUN ERRORESCACLIC (MENSAJE)
   (ATRASESCACLIC)
  (SETQ MENSESCACLIC
        (IF (= MENSAJE "dividir por cero")
          (PRINC "\n****¡Ese largo de escalera es muy reducido!....
          ¡Ingrese otro largo mayor!****
         dividir por cero")
        )
   )
     (PRINC)
);FUNCION DE ERROR AL INGRESAR UN DATO ERRONEO
;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(DEFUN PROCESODEDATOSESCACLIC1 ()
  (SETQ INCLINADA (DISTANCE ARR LLEG));TRIANGULO DE TODA LA ESCALERA
  (SETQ NUMMOD (/ INCLINADA 0.35))
  (SETQ CANT (FIX NUMMOD));NUMERO DE MODULOS DIAGONALES
   (SETQ ANGESCABS (ATAN (/ ALT DESH)));ANGULO DE ESCALERA ABSOLUTO
    (SETQ ANGESCGRAD(* ANGESCABS (/ 180 PI)));ANGULO ESCALERA EN GRADOS
  (SETQ CONTRAHUELLA1 (* 0.35 (SIN ANGESCABS))
     NUEVAALT (* CANT CONTRAHUELLA1)
      HUELLA1 (* 0.35 (COS ANGESCABS))
       NUEVODESH (* CANT HUELLA1)
        CORRECHUELLA (/ ALT NUEVAALT)
         CORRECCONTRAHUE (/ DESH NUEVODESH)
          CONTRAHUELLA (* CORRECCONTRAHUE CONTRAHUELLA1)
           HUELLA (* CORRECHUELLA HUELLA1)
   )
    );CALCULO Y CORRECCION DE HUELLA Y CONTRAHUELLA

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(DEFUN PROCESODEDATOSESCACLIC2 ()
  (SETQ PT1 ARR)
        (IF(= DIRECCIONAL 1)(SETQ PT2 (POLAR PT1 (/ PI 2) CONTRAHUELLA)))
     (IF(= DIRECCIONAL 2)(SETQ PT2 (POLAR PT1 (/ PI 2) CONTRAHUELLA)))
     (IF(= DIRECCIONAL 3)(SETQ PT2 (POLAR PT1 PI HUELLA)))
     (IF(= DIRECCIONAL 4)(SETQ PT2 (POLAR PT1 0 HUELLA)))
         (COMMAND "_PLINE" PT1 PT2 "")
  (SETQ PT1 PT2)
   (IF(= DIRECCIONAL 1)(SETQ PT2 (POLAR PT1 0 HUELLA)))
  (IF(= DIRECCIONAL 2)(SETQ PT2 (POLAR PT1 PI HUELLA)))
  (IF(= DIRECCIONAL 3)(SETQ PT2 (POLAR PT1 (* PI 1.5) CONTRAHUELLA)))
  (IF(= DIRECCIONAL 4)(SETQ PT2 (POLAR PT1 (* PI 1.5) CONTRAHUELLA)))
       (COMMAND "_PLINE" PT1 PT2 "");DIBUJO DE UN ESCALON
  (REPEAT (- CANT 1)
    (SETQ PT1 PT2)
       (IF(= DIRECCIONAL 1)(SETQ PT2 (POLAR PT1 (/ PI 2) CONTRAHUELLA)))
     (IF(= DIRECCIONAL 2)(SETQ PT2 (POLAR PT1 (/ PI 2) CONTRAHUELLA)))
     (IF(= DIRECCIONAL 3)(SETQ PT2 (POLAR PT1 PI HUELLA)))
     (IF(= DIRECCIONAL 4)(SETQ PT2 (POLAR PT1 0 HUELLA)))
       (COMMAND "_PLINE" PT1 PT2 "")
    (SETQ PT1 PT2)
     (IF(= DIRECCIONAL 1)(SETQ PT2 (POLAR PT1 0 HUELLA)))
  (IF(= DIRECCIONAL 2)(SETQ PT2 (POLAR PT1 PI HUELLA)))
  (IF(= DIRECCIONAL 3)(SETQ PT2 (POLAR PT1 (* PI 1.5) CONTRAHUELLA)))
  (IF(= DIRECCIONAL 4)(SETQ PT2 (POLAR PT1 (* PI 1.5) CONTRAHUELLA)))
          (COMMAND "_PLINE" PT1 PT2 "")
   )

);RESTO DE ESCALONES

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(DEFUN PROCESODEDATOSESCACLIC3 ()
  (SETQ RELACIONDEPASO (+ (* 2 CONTRAHUELLA) HUELLA));RELACION DE PASO DE LA ESCALERA
  (SETQ PASOREALDIAGONAL (/ CONTRAHUELLA (SIN (/ ANGESCABS 2))));PASO REAL DIAGONAL
);FIN DE PROCESO DE DATOS

  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
(DEFUN MOSTRARRESULTADOSESCACLIC ()
  (PROMPT "\n*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*")
  (PROMPT "\nLA DIRECCIONAL INGRESADA ES: ")
        (IF (= DIRECCIONAL 1)(PRINC "HACIA DERECHA Y ARRIBA"))
        (IF (= DIRECCIONAL 2)(PRINC "HACIA IZQUIERDA Y ARRIBA"))
        (IF (= DIRECCIONAL 3)(PRINC "HACIA IZQUIERDA Y ABAJO"))
        (IF (= DIRECCIONAL 4)(PRINC "HACIA DERECHA Y ABAJO"))
  (PROMPT "\nALTURA VERTICAL ENTRE NIVELES: ")
  (PRINC ALT)
  (PROMPT "\nDESARROLLO HORIZONTAL: ")
  (PRINC DESH)
  (PROMPT "\nLARGO DIAGONAL TOTAL: ")
  (PRINC INCLINADA)
   (PROMPT "\nEL NUMERO DE ESCALONES DETERMINADO PARA ESTE CASO ES: ")
   (PRINC CANT)
  (PROMPT "\nANGULO DE LA ESCALERA: ")
   (PRINC ANGESCGRAD)
    (PROMPT "º")
  (PROMPT "\nVALOR DE HUELLA: ")
   (PRINC HUELLA)
  (PROMPT "\nVALOR DE CONTRAHUELLA: ")
   (PRINC CONTRAHUELLA)
  (PROMPT "\nLA RELACION DE PASO (2CH+1H) CALCULADA ES: ")
   (PRINC RELACIONDEPASO)
  (PROMPT "\nEL PASO REAL DIAGONAL PARA PERSONAS EN ESTA ESCALERA ES: ")
   (PRINC PASOREALDIAGONAL)
     (PROMPT "\n*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&*")
  (PROMPT "\n*....© AUTOR: VICTOR ADOLFO BRACAMONTE....2007....*")
  (PRINC)
);FIN DE MOSTRAR RESULTADOS

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(DEFUN REST_VARESCACLIC ()
  (COMMAND "_OSMODE" 4133)
  (COMMAND "_PICKBOX" 3)
  (PRINC)
);RESTITUIR VARIABLES DE SISTEMA EN ESCACLIC

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,

(DEFUN C:ESCACLIC (/ ALT DESH PT1 PT2
     ANT_ERROR *ERROR*)
  (SETQ ANT_ERROR *ERROR*
        *ERROR* ERRORESCACLIC)
  (ENTRADADEDATOSESCACLIC)
    (VAR_VARESCACLIC)
     (PROCESODEDATOSESCACLIC1)
      (PROCESODEDATOSESCACLIC2)
       (PROCESODEDATOSESCACLIC3) 
        (MOSTRARRESULTADOSESCACLIC)
         (REST_VARESCACLIC)
  (SETQ *ERROR* ANT_ERROR)
);FIN DE ESCACLIC

Archivos scripts para hacer rutinas (*.scr):

2008-04-01T13:49:00.000-07:00


Con el comando "_script" de AutoCAD,
se pueden llamar archivos de extensión "*.scr"
realizados en el bloq de notas, siguiendo
lineas de comandos que reproducen
acciones completas del usuario, solo
se deben grabar las líneas introducidas
en la ventana de comandos, en un
orden cuidado.......Este método es
extremadamente sensible a los espacios
en blanco y a los saltos de lineas.
Todo script termina con el cursor en
la linea siguiente a la última órden
pero en el borde sin crear espacio en blanco
y todo salto de linea o línea en blanco
equivale a un ENTER.
(****Siempre al terminar cualquier comando de autocad, si se da ENTER,
repite el comando****).
En _script todo espacio vacio es un ENTER. 
---------------------------------------
Un ejemplo:
Quiero tener un script que me haga
2 circulos concentricos de radios
300 y 500:
El script sería:
-----------------------------------
_circle
0,120
300

0,120
500

--------------------------------------ver adjunto
Otro ejemplo:
Hacer un script que audite y purgue un archivo:
sería:
----------------------------------------
_audit
_y

_purge
_a
*
_n

-----------------------------------------ver adjunto
*Al margen:
Si quiero repetir el último script ejecutado
ingreso el comando "_rscript".
Y si quiero poner comentarios dentro del
script hago lo mismo que en Autolisp,
punto y coma ";" y la linea siguiente
es comentario, pero por ser un script
tan sensible a los espacios en blanco,
no recomiendo poner lineas extras en él,
para poder concentrarse en lo importante
que es la secuencia de comandos con los
espacios "exactos"........

Lenguajes de programación en AutoCAD:

2008-03-27T21:28:00.000-07:00

Tabla resúmen de los lenguajes usuales para programar en AutoCAD:
*Click en la imágen para ampliar*

Comando "fsigpl": para escribir un texto o frase siguiendo la curvatura de un objeto lineal de base.

2008-03-26T21:58:00.000-07:00

Supongamos que necesito escribir una frase cualquiera
siguiendo una curva dada, entonces dibujo un objeto
lineal que me sirva de eje, el cual lo pedirá la rutina,
y luego queda solo el texto curvado y borra el eje:


;|*********************************************
          Rutina "fsigpl" frase que sigue
          la curva de un objeto lineal........
  *********************************************
   by (c) Prexem Victor Adolfo Bracamonte 2008
  *********************************************
  --------    www.prexem.blogspot.com   -------
  *********************************************|;
(prompt
  "\n****La rutina requiere
  \nun objeto lineal para eje del texto\n*****"
)
(defun bloqtextinmeasure (/       capa_ant   alt
     frase       cant_espacios
     plineb      osmant   picant
     vla_plineb  pt   long_plineb
     separac     ent_text   cont
     dat_text    pt_inic   ang_rotac
     ang_rotac_text   caract
     eras
    )
  (vl-load-com)
  (setq capa_ant (getvar 'clayer))
  (command "_layer" "_m" "c-ap" "_c" "1" "c-ap" "")
  (setq alt       (getdist "\naltura de texto:")
 frase
        (getstring t
   "\nFrase a escribir en curva:"
        )
 cant_espacios (strlen frase)
  )
  (setvar "clayer" "c-ap")
  (setq plineb
  (car
    (entsel
      "\nSeleccione polilinea u objeto lineal base:"
      )
  )
  )
  (setq osmant (getvar "osmode"))
  (setvar 'osmode 0)
  (setq picant (getvar "pickbox"))
  (setvar 'pickbox 0)
  (setq vla_plineb  (vlax-ename->vla-object plineb)
 pt     (vlax-curve-getstartpoint vla_plineb)
 long_plineb
      (vlax-curve-getdistatparam
        vla_plineb
        (vlax-curve-getendparam vla_plineb)
      )
 separac     (/ long_plineb cant_espacios)
  )
  (command "_text" pt alt "0" "b1")
  (command "_block" "c-ap" pt (entlast) "")
  (setq ent_text (entlast))
  (command "_measure" plineb "b" "c-ap" "_Y" separac)
  (setvar "clayer" capa_ant)
  (setq cont 0)
  (repeat cant_espacios
    (setq ent_text (entnext ent_text)
   dat_text (entget ent_text)
    )
    (setq pt_inic  (cdr (assoc 10 dat_text))
   ang_rotac  (cdr (assoc 50 dat_text))
   ang_rotac_text (angtos ang_rotac 2 2)
   caract  (substr frase (+ cont 1) 1)
    )
    (command "_.text" pt_inic alt ang_rotac_text caract)
    (setq cont (+ cont 1))
  );repeat
  (setq eras
  (ssget "_X"
  (list
    (cons 0 "INSERT")
    (cons 8 "c-ap")
  )
  )
  )
  (command "_erase" eras "")
  (command "_erase" plineb "")
  (command "_laydel" "_n" "c-ap" "" "_Y")
  (command "_purge" "_A" "*" "_N")
  (setvar 'osmode osmant)
  (setvar 'pickbox picant)
  (princ)
);defun
(defun err1 (m)
  (progn
    (prompt "*Fin de la aplicacion*")
    (setvar 'osmode osmant)
    (setvar 'pickbox picant)
    (princ)
  )
)
(defun c:fsigpl (/ errant *error*)
  (setq errant *error*
 *error* err1
  )
  (bloqtextinmeasure)
  (setq *error* errant)
  (princ)
)

Cambiar un determinado tipo de bloque por otro dando los nombres:

2008-03-22T13:26:00.000-07:00


;|   Hacer un comando para cambiar un tipo de bloque
     por otro........
------------------------------------------------------|;
(defun c:cambia_bloq  ( /
                      cmdant
         osmant
         nombre_ant
         sel
         cont
         nombre_post
         bloque
         data
         )
;|   Guardo valores de variables
     y las establezco en 0:        |;
 (setq cmdant (getvar 'cmdecho))
    (setvar "cmdecho" 0)
 (setq osmant (getvar 'osmode)) 
    (setvar "osmode" 0)
;|   Pide el nombre del bloque a
     cambiar, es el nombre asignado por el usuario,
     luego hace una seleccion por nombre,
   de todos los bloques en todas las capas ....
     Y pide el nombre del nuevo bloque:        |; 
 (setq nombre_ant (getstring "\nDar nombre de bloque a cambiar: ")
       sel (ssget "_X" (list (cons 0 "INSERT")(cons 2 nombre_ant)))
 cont 0
 nombre_post (getstring "\nDar nombre de bloque nuevo: ")
 )
;|   En un buclé "repeat" que se repite tantas
     veces como bloques hayamos seleccionado,
     extrae nombre de entidad-autocad de cada uno,
     con ello extrae la lista-data de cada bloque,
     modifica el nombre en esa lista-data,
     con la nueva lista-data modifica el objeto con "entmod"
     y luego recrea la imagen del bloque con "entupd":        |;
 (repeat
   (sslength sel)
   (setq bloque (ssname sel cont))
   (setq data (entget bloque))
   (setq data (subst (cons 2 nombre_post) (assoc 2 data) data))
   (entmod data)
   (entupd bloque)
   (setq cont (+ cont 1))
   );repeat
;|    Vuelve atrás valores de variables:    |; 
  (setvar "cmdecho" cmdant)
 (setvar "osmode" osmant)
 (princ)
 );fin defun

Comando "chcolor" en vlisp, para seleccionar objetos por color y cambiar color por otro:

2008-03-12T03:38:00.000-07:00

;;;----Rutina "chcolor"
;;;----pide numero de color a buscar
;;;----y numero de color nuevo
;;;----selecciona objetos segun color
;;;----y cambia color por el nuevo
;;;----luego queda indicada la
;;;----selección.
;;;***********************************************************
;;;*(c) by Prexem - Víctor Adolfo Bracamonte - 2008*
;;;***********************************************************
(defun c:chcolor ( /
color-busc
newcolor
sel
cant
index
selxcol
ent
vla-obj
color-obj
)
(vl-load-com)
(setq color-busc
(getint
"\nDar numero del color buscado: "
)
newcolor
(getint
"\nDar numero del color nuevo: "
)
)
(setq sel (ssget "_X")
cant (sslength sel)
index 0
selxcol (ssadd)
)
(repeat cant
(setq ent (ssname sel index)
vla-obj (vlax-ename->vla-object ent)
color-obj (vla-get-color vla-obj)
)
(if (equal color-busc color-obj)
(setq selxcol (ssadd ent selxcol))
);if
(setq index (1+ index))
);repeat
(command "_chprop" selxcol "" "c" newcolor "")
(sssetfirst nil selxcol)
(prompt "\n*ESCAPE para deseleccionar*")
(princ)
);fin defun

Rutina vlisp para numerar secuencialmente bloques desde un número inicial dado:

2008-03-10T15:39:00.000-07:00

;;; Numerador secuencial de bloques
;;; comando "num_bl"
;;; (c) by PREXEM -
;;; Víctor Adolfo Bracamonte - 2008.
;;;*************************************
(defun c:num_bl (/
osmodant
cmdant
mob_bl
sel
n
numero
cont
bl
pt0
pttext
)
(setq osmodant (getvar 'osmode))
(setvar "osmode" 0)
(setq cmdant (getvar 'cmdecho))
(setvar "cmdecho" 0)
(setq nomb_bl
(getstring t "\nDar nombre del bloque: ")
)
(prompt "\nSeleccione Bloques : ")
(setq sel (ssget
(list
(cons 0 "INSERT")
(cons 2 nomb_bl)
)
)
n (sslength sel)
numero (getint "\nDar numero inicial: ")
cont 0
)
(repeat n
(setq bl (ssname sel cont)
pt0 (cdr (assoc 10 (entget bl)))
pttext (mapcar
'+
pt0
(list 10 10 0)
)
)
(command "_.text"
"_J"
"_R"
pttext
""
""
(itoa numero)
)
(setq cont (1+ cont)
numero (1+ numero)
)
);repeat
(setvar "osmode" osmodant)
(setvar "cmdecho" cmdant)
(princ)
);fin defun

Video Tutorial para hacer bloques dinámicos en español:

2008-03-05T14:20:00.000-08:00

Un video que muestra detalladamente y paso a paso la construcción de un bloque dinámico de

una vista de una mesa de ancho variable (Archivo de 9,5 minutos y 36 Mb de peso):

Rutina LISP para suprimir grupos de textos de igual parte final:

2008-03-01T23:44:00.000-08:00

Supongamos que tenemos en cualquier capa textos o multitextos con una misma
parte final, y los queremos suprimir dando ese final, ejemplo:
Tengo textos y multitextos de esta manera:

puerta21
ventana21
puertas21
entrada1

Y los quiero suprimir dando solo la parte final, entonces llamo al comando
"deltf" y cuando pide parte final pongo: 1
Entonces me suprime todos los _text o _mtext que finalicen en "1"........
Código LISP:

;;;Rutina "deltf" borra textos o multitextos
;;; dando el final de los mismos.
;;;.........................................
;;;by PREXEM - prexem@gmail.com - 2008.
;;; .........................................
(defun c:deltf ( /
fin
sel
cant
cont
)
(setq fin
(strcat "\52"
(getstring "\ndar final de texto a seleccionar: "
)
)
)
(setq sel
(ssget "X"
(list
(cons 0 "TEXT,MTEXT")
(cons 1 fin)
)
)
cant (sslength sel)
cont 0
)
(repeat cant
(entdel (ssname sel cont)
)
(setq cont (1+ cont)
)
)
(prompt
(strcat
"\n*Se han suprimido " (itoa cant) " textos*"
)
)
(princ)
) ;fin defun deltf

Link para descarga de lista de funciones autolisp hasta versión 2004

2008-02-28T20:06:00.000-08:00

http://www.arch.nctu.edu.tw/~jhou/download/VisualLISP_Functions.pdf

En Autolisp Comando "fillet" aplicado a sólidos 3d para redondear aristas:

2008-02-26T12:56:00.000-08:00

;;;---- rutina para hacer fillet en aristas en
;;;----un 3dsolid...."fill_sol3d"
;;;----*************************************
;;;----*(c)by Prexem -
;;;----Víctor Adolfo Bracamonte - 2008*
;;;----*************************************
(defun c:fill_sol3d ( /
sol3d
radio
filltrant
)
(setq sol3d
(car
(entsel
"\nseñale el solido a redondear aristas: "
)
)
radio
(getreal
"\ndar radio del redondeo de arista: "
)
) ;setq
(setq
filltrant
(getvar 'filletrad)
)
(setvar "filletrad" radio)
(command "_.fillet" "t" "t" sol3d)
(prompt
"\n....
\n****Seleccionar aristas a redondear y terminar con ENTER****:"
)
(command pause "")
(setvar "filletrad" filltrant)
(princ)
) ;fin fill_sol3d

*Las Capas entre Software y Hardware (Sistema de la PC II)........

2008-02-25T15:38:00.000-08:00

*Otro tema ilustrativo para comenzar a tocar temas de Programación,
es "Capas de Software que unen al Usuario con la PC o Hardware":

Anteriormente hablamos de que la Máquina solo es capaz de interpretar
la existencia de "pulsos" o "no-pulsos", lo que lee como "1" o "0",
de allí surge un lenguaje "binario" basado solo en ceros y unos, esto puede
interpretarse directamente como un código de máquina, pero de allí surgen
otros lenguajes simbólicos de lectura directa desde el hardware, y en esa
capa se ubican los lenguajes de "Bajo nivel" donde están los "Drivers",
que dialogan directamente con los circuitos electrónicos en base a lo
que haga el operador desde los periféricos (Mouse, teclado, etc.), los
drivers deben ser programados acordes a cada parte electrónica y
en código muy simbólico.........La siguiente capa superior es todo código
"Ensamblador o Nexo" hacia el sistema operativo........La siguiente capa
superior es el "Kernel" o "Núcleo de raíces controladoras del tráfico de
procesos del sistema operativo", se une directamente a los drivers con
imágenes abstractas de ellos y del hardware, y se programa con lenguajes
muy cercanos al nivel simbólico que tienen los anteriores, aquí se crea
la "interfaz" para programación desde el sistema o desde otros programas
hacia la máquina.........La siguiente capa hacia arriba es lo que llamamos
"Interfaz de Sistema" es todo lo visible del Windows o DOS u otro sistema
operativo, y es lo que genera el entorno de uso común de la PC........
En la siguiente capa de software hacia arriba ya tenemos los programas
como AutoCAD, y como átomos del mismo encontramos las API (Application
Programming Interface - Interfaces de Programación de Aplicaciones), son
programas intérpretes y bibliotecas de interpretación dentro de editores
de creación y cargado de ciertos lenguajes como el Autolisp, es allí donde
se suelen hacer las rutinas en vlisp y cargarlas, aunque también se pueden
hacer en cualquier editor de textos y guardarlas con extensión *.lsp para
que esa API las pueda leer.

*Resumiendo, la cadena entre hardware y programas es así:

*HARDWARE (LA MÁQUINA)>>>>
*DRIVERS (PROGRAMAS EN CÓDIGO DE BAJO NIVEL)>>>>
*ENSAMBLADORES (LENGUAJES INTERMEDIOS)>>>>
*NÚCLEO DE SISTEMA (LENGUAJES INTERMEDIOS)>>>>
*SISTEMA Y PROGRAMAS (LENGUAJES DE ALTO NIVEL)*

*Sobre el Sistema de un Computador:

2008-02-24T17:03:00.000-08:00

*¿Qué es un Ordenador?:
(Una introducción al concepto de "Sistema")........

Es una máquina electrónica "ordenadora" de "datos-argumentos-pulsos", en base a pasos o conducciones eléctricas, capaces de registrar cambios ante situaciones de"pulsión" y "no-pulsión" de corrientes transformadas de ciertas maneras, esos registros derivan en interpretaciones binarias "si" o "no" que luego son traducibles a lenguajes intérpretes y a su vez a lenguajes cognoscibles por seres humanos, siendo ese proceso factible de concretar entre humano y máquina....

Esto es lo que posibilita la creación de ciertos"softwares" según los cuales el ordenador filtra datos o argumentos ingresantes o egresantes en un sentido esperado por el programador....

Datos o argumentos que ingresan son "inputs" y los que egresan son "outputs" en términos de "pulsos"....
Actualmente los datos o argumentos de entrada o salida pueden ser de texto, visuales, de sonido o multimediales....

*Software----es el conjunto de programas escritos en cualquier lenguaje y cargados o instalados en el ordenador.

*Hardware----es el conjunto de lo electrónico-físico de la PC.

*Programa----es un conjunto serial o de lista, de datos o argumentos que basamentan el comportamiento del ordenador en sus procesos.

*ESQUEMA DE UN SISTEMA DE HARDWARE:

*Básicamente existen dispositivos de entrada o de inputs, de proceso y guardado y de salida o de outputs, aunque también existen dispositivos mixtos o múltiples....Sin embargo el sistema es una permanente interacción entre Operador y Maquina:

>>>>INPUTS>>>>PROCESOS>>>>OUTPUTS>>>>

*Los mecanismos de guardado-memoria se ubican entre los procesos unificados en el Gabinete de la CPU o muy unidos a la misma por puertos específicos o USB....

*Ejemplos de Dispositivos de entrada:
• Teclados.• Lápices ópticos.• Scanner.• Micrófonos.• Mouse.• Cámaras.

*Ejemplos de Dispositivos de salida:
• Monitores.• Impresoras y plotters.• Parlantes.

*La Unidad Central de Proceso (CPU):

Es la máquina de procesos central, se compone esencialmente por:

• Unidad de control:
Controla los procesos de la computadora y determina que operaciones se deben realizar y en que orden.
• Unidad aritmética Lógica:
Realiza operaciones aritméticas, lógicas y de comparaciones.
• Dispositivos de memoria:
Todos los medios de almacenamiento que se unen a la CPU.

*Las distintas memorias de la computadora:

En sus procesos de datos o argumentos, la máquina central y los distintos componentes mas o menos periféricos, utilizan 3 tipos de memorias que pueden estar centralizadas en un solo lugar o dispuestas dentro de cada sub-componente:

*----Memoria temporal o RAM que sirve solo para retener lo necesario para el tránsito del procesamiento....
*----Memoria de guardado de datos y programas que sirve para almacenar u modificar datos usables si o no en procesos....
*----Memoria ROM que guarda datos y software o firmware que debe contener información no modificable, configuraciones y programas de inicio del hardware....

*Memoria de guardado modificable:
Es de almacenamiento permanente, tanto para programas como para datos , y es accesible o modificable por el operador en general (Disco Duro)....Además se utilizan otros medios de almacenamiento modificable como unidades de CD/DVD, Pendrives, disco duro removible, etc....

*Sobre los lenguajes de programación:
Los programas componentes de un sistema se expresan en lenguajes, que pueden ser:

*Lenguaje de máquina---->código binario dependiente directo del hardware.
*Lenguaje ensamblador---->código traductor de lenguaje a binario. (Bajo nivel)
*Lenguaje traducible---->lenguaje de programador traducible a binario. (Alto nivel)

*Lenguajes de alto nivel:
Es posible programar en todos los niveles de lenguaje, pero los de alto nivel son más usados debido a que son muy manejables por usuarios medios, esto crea gran dicotomía, o sea lenguajes mejor interpretables por máquinas son mas veloces en su operación pero difíciles de inteligir por humanos, a su vez lenguajes textuales y visuales mas inteligibles por cualquier operador, pero deben tener programas traductores (API) muy pesados que ralentizan las operaciones de la PC....Pero con los elementos que poseen de interpretabilidad, facilitan enormemente el poder crear software adecuado a lo que cada programador desea....Estos lenguajes son muy adecuados al tipo de hardware que toman como base, ya que todos los lenguajes de traducción vienen adecuados a las posibles diferencias entre PC's compatibles con IBM y para los sistemas operativos actuales....

*Tipos de lenguajes de alto nivel:
C,VisualBasic,JavaProlog,LISP,Autolisp, HTML,XML,JavaScript, etc.

*Los más usados en sistemas de diseño asistido por ordenador: Autolisp-VBA.
*Los más usados para customización de operaciones de oficina: VB, C.
*Para desarrollo de software----JAVA.----orientado a objetos, y otros........

*CONCLUSIONES:

“El operador es parte del sistema de cómputo”........Lo más importante en todo esto es la interacción Usuario/Computadora, ya que las máquinas carecen actualmente de poder auto-evolutivo y de auto-control en sus procesos, el programador es el "Cerebro" real de la PC, quién introduce los programas-guías, aquí surgen las necesarias herramientas para desarrollo de software que deben ser adecuadas tanto a las posibilidades de la máquina como a las del desarrollador.

*Respecto a la Visión Global de "Sistema", podemos decir que dentro del Software de una PC,
en el entorno Windows se ubica el Software AutoCAD, el cual a su vez está conformado
por programas de operación y de desarrollo, dentro de los de desarrollo de software o de
personalización del AutoCAD, vienen las API, que son las interfaces de
ciertos lenguajes soportados o admitidos como el Autolisp, el Visual Basic App u otros, y
dentro de la API ALisp es donde creamos las "rutinas vlisp" que son interpretadas hacia un
"Lenguaje de máquina" para que puedan operar debidamente.

*Se viene el AutoCAD 2009........

2008-02-19T20:17:00.000-08:00

*Renovado totalmente y con funciones que acentúan la tendencia hacia un uso muy

intuitivo del programa, menús y ventanas retráctiles para buscar más espacio para

la ventana gráfica central y una interfaz aún más visual que en versiones anteriores

además de funciones que mejoran el rendimiento y uso del mouse en general.

*Entre otras características renovadas trae:

*Ventana emergente con tips y gráficos de cada comando al posar el cursor.

*Buscador de menús.

*Picando un objeto se despliega ventana rápida de "propiedades editables".

*Vista rápida de presentaciones.

*Vista rápida de dibujos.

*Más posibilidades de configuración de la navegación 3d.

*Mejores posibilidades en cuanto a vistas de movimiento.

*Mejoras en cuanto a "Búsqueda y Reemplazo".

*Mejor navegación por cubo de vistas (Superior, inferior, derecha, etc.).

*Trae una ventana de historial de acciones, algo que recuerda al Photoshop.

*La nueva interfaz:

*Link para descarga de la guía rápida de novedades del AutoCAD 2009:

http://rapidshare.com/files/93317638/autocad_2009_preview_guide_final.pdf

*Página de la guía de producto acad 2009:

http://autodesk.blogs.com/between_the_lines/2008/02/the-2009-produc.html

*Guía de novedades de la versión:

http://cadit.typepad.com/my_weblog/2008/02/autocad-2009--.html

*Sobre el Visual LISP:

2008-02-16T01:59:00.000-08:00

*Comentarios sobre el lenguaje:

Proviene del Common-lisp, adaptado al diseño “visual” o de ayudas visuales para el programador……..A su vez la serie de lenguajes “LISP” (Lenguaje intérprete de listas), comienza con un sistema creado hacia los años 50’s / 60’s en el MIT por John McCarthy……..Fue creado como un “Diálogo con Máquinas capaces de adquirir intelecto artificial” de allí su parecido con un“Informador de órdenes” mas que una serie lógica como suelen ser muchos lenguajes, posee algo de “Recursión informativa de las órdenes”, lo que parece “Poco eficiente”,sin embargo ello agiliza enormemente la comprensión del programador respecto a los mecanismos creados a implementar cuasi roboticamente por el computador........No obstante es menester siempre la ulterior “depuración de códigos” para resumirlos o sintetizarlos.

*Vamos a un ejemplo para aclarar:

;;;**********************************************
;;;---- Un programita en autolisp
;;;***********************************************
;;;La particularidad más visible del autolisp es que todo va
;;;entre paréntesis, con igual número de paréntesis de apertura
;;;que de cierre, y si algo está luego de punto y coma es
;;;solo comentario.........
;;;defino función con “defun” y es el comienzo del diálogo:
(defun adiciona (esto1 esto2 / es) ;defino adiciona esto mas esto y es
(setq es (+ esto1 esto2)) ;es significa sumar esto mas esto
(princ es) ;imprima es
(princ) ;nada mas
) ;termina
;;;si pongo en linea de comandos:
;;;(adiciona 1 3)---->devuelve 4
;;;posee una lógica de diálogo operador-máquina.

*Algunos caracteres del lenguaje VLISP:

• -Posee creatividad interactiva visual.
Ello a través de un “Editor de vlisp” con código de colores sintáctico.
• -Los argumentos admitidos pueden ser variables - simbólicos o constantes - numéricos.
• -Parte de la lista encerrada entre paréntesis como modo estructural - sintáctico.
• -Las listas van precedidas por funciones preconcebidas.
• _Los comentarios van precedidos por punto y coma (;).
• -Es un lenguaje que es interpretado por un lenguaje “nexo” hacia el lenguaje de máquina........(Ello es el “intérprete de Autolisp-Vlisp”).
• _El intérprete gestiona listas en el sentido de la lectura (De arriba hacia abajo y de izquierda a derecha, comenzando desde las listas intra-paréntesis más internas hacia las mas externas, siempre buscando luego de un paréntesis de apertura “(“ alguna “Función preconcebida” (Para evaluarla) y luego busca sus correspondientes datos o argumentos los que siempre deben ser de un tipo predeterminado (Número, Real, Entero, cadena de texto, etc.) , y finalmente busca el correspondiente paréntesis de cierre de la lista “)”, lo que hace al cierre lógico de la función que preside la lista.

*Tipos de funciones en vlisp:

Aritméticas---- + - / *
Inicia comandos---- command, vl-cmdf
Conversion de datos o argumentos ----- rtos, atoi
Caracteres de Control en cadenas de texto ---- “\n \t \e \”
Control de pantalla ---- textscr, graphscr, princ, prompt, alert
Manejo de entidades ---- entsel, entmod, nentsel, entmake, entdel
Condicionales ----if, cond
Comparación ---- =, equal, <, >, <=, /=
Manejo de archivos ---- getfiled, open, close
Manejo de funciones ---- lambda, defun, function, progn
Geométricas ---- polar, osnap, inters, distance, angle
Manejo de listas ---- list, cons, append, apply, mapcar, foreach, length
Selección de objetos ---- ssget, sslength, ssadd
Creación definición de variables ---- set, setq, quote, atom, ‘ (apostrofo=quote)
De cadenas de texto ----read, strcat
Pedido de datos ---- getpoint, getstring, getangle, getorient, getcorner

*Mas adelante ampliaremos sobre funciones de vlisp........

*Las características del lenguaje lo hacen an-abstracto o sea muy adecuado a una creación imaginativa de estructuras de procesos por parte de usuarios medios de AutoCAD. Ello lo hace muy Amigable.
*La búsqueda principal en vlisp es favorecer la "Customización en un diálogo usuario- computador" más que establecer un lenguaje de alto desarrollo de software.........

*Sobre la Customización en el Diseño Computarizado:

2008-02-03T15:03:00.000-08:00

*Hoy en día es común el empleo de Sistemas Computarizados para asistencia en Diseño. Con lo standard y básico de estos softwares, la ayuda brindada es realmente importante, pero ello es solo parte de lo que puede lograr una computadora, ampliar esos horizontes es lo que llamamos "Customización" o sea "Poder Personalizar el Comportamiento de la PC hasta ciertos límites acorde a nuestra necesidad en el Diseño", ello es posible de muchas maneras, especialmente en AutoCAD se puede customizar todo el entorno y la interfaz de trabajo, barras de herramientas, botones, colores, menús, etc. Pero además existe la atractiva posibilidad de crear "Comandos y Funciones Nuevos" que amplíen las operaciones normales de AutoCAD, ........ ello requiere entrar en el mundo de la "Programación", sea con Autolisp, con VisualBasic-ACAD u otro lenguaje aceptado por el programa principal........El motivo principal de la Customización es lograr trabajar "Ágilmente y con Mayor Productividad" creando los sub-programas que necesitamos dentro del sistema........Se puede decir que todo "Método de Trabajo de un Diseñador" puede ser potenciado "Adaptando el sistema al Individuo"; para ello es necesario "Programar" lo que deseamos mejorar en las funciones de AutoCAD ........ Se puede decir que el futuro en el uso de programas de diseño viene de la mano de la "Customización".