Adicionar no arquivo ACADR14.

LSP o seguinte:

(autoload "zitem" '("i1" "i2"))

(autoload "zcomandos" '("11" "12" "10" "14" "15"
"21" "22" "23" "24" "25" "26" "27" "28" "29"
"31" "32" "33" "34" "35" "36" "37" "39"
"41" "42" "43" "44" "49"
"51" "52" "53" "54" "55" "56"
"61" "62" "63" "64" "65" "66"))
(autoload "znumera" '("num"))

Esse procedimento faz com que o AutoCAD carregue as rotinas em LISP, sempre que você carregar

um novo arquivo.
Command: i1

Initializing...cmdecho
New value for CMDECHO <1>: 0
Clique na peca: : [clique na tela]
Clique na posicao da bola do item: [clique na tela novamente]
Entre com o diametro da bola: 15

Entre com o texto: 01 [coloque o texto que vai ficar dentro da bola(2 digitos)]

O novo comando criou rapidamente o que você teria que fazer com vários comandos. A altura do
texto foi defino como proporcional ao diâmetro da bola.

Veja abaixo como fica o desenho:

Exemplo 1: Comandos criados pelo usuário:

Este exemplo mostra o conteúdo de um arquivo AutoLISP em que foram criados comandos
particulares para auxílio do usuário. De maneira similar, você poderá criar seus próprios comandos.

Estes comandos podem estar num arquivo chamado, por exemplo de comandos. Lsp. O método de
criá-lo digitando o usando um editor qualquer e salvá-lo no modo texto, sem caracteres especiais.
;
; Costumização para teclados para AutoCAD
;
; Atalho para comandos permanentes
;
(defun c:1() (command “osnap” “end,int,cen”) (princ))
(defun c:2() (command “osnap” “”) (princ))
(defun c:f0() (command “fillet” ”r” “ 0”) (command “fillet”) (princ))
(defun c:pe() (command “pedit”) (princ))
(defun c:l() (command “line”) (princ))
(defun c:cc() (command “circle”) (princ))
;
; COMANDOS DE SETAGEM DE COR
;
(defun c:c1() (command “color” “1”) (princ))
(defun c:c2() (command “color” “2”) (princ))
(defun c:c3() (command “color” “3”) (princ))
;
; COMANDOS DE TROCA DE COR
;
(defun c:c1c() (princ “\nSelecione objetos para mudar cor para RED: “) (command “select” “auto” pause)
(command “chprop” “p” “” “c” “1” “”) (princ))
(defun c:c2c() (princ “\nSelecione objetos para mudar cor para YELLOW: “) (command “select” “auto”
pause)
(command “chprop” “p” “” “c” “2” “”) (princ))
(defun c:c3c() (princ “\nSelecione objetos para mudar cor para GREEN: “) (command “select” “auto” pause)
(command “chprop” “p” “” “c” “3” “”) (princ))
;
; COMANDOS DE SETAGEM DE TIPO DE LINHA
;
(defun c:L1() (command “linetype” “s” “continuous” “”) (princ))
(defun c:L2() (command “linetype” “s” “hidden” “”) (princ))
(defun c:L3() (command “linetype” “s” “dashdot” “”) (princ))

Observe que o sinal “;” permite a inserção de comantários no arquivo.

Observe que os comandos gerados acima são apenas atalhos para os comandos já existentes no
AutoCAD, permitindo assim maior velocidade na entrada do comando. Você poderá inventar comandos que
melhor se adaptem ao seu modo de trabalho.

Exemplo 2 – Rotina para itemizar projetos

Muito usado em projetos mecânicos e outros que precisam de uma lista de materiais, a itemização
sempre faz com que percamos algum tempo fazendo sua simbologia. A rotina que segue nos ajudará a
desenhar a simbologia mais facilmente.

Bastará clicar em um ponto da peça, um ponto onde deseja o círculo de itm e qual texto deseja
acrescentar.

A rotina poderá ser salva em um arquivo chamado ITEM.LSP ou outro qualquer de sua preferência.
O mesmo poderá ser alterado para se adptar à sua forma de trabalho.
;
; Arquivo: ITEM.LSP
;
; Função da rotina: Criar simbologia de itemizacao
;
; Comandos criados: I1 – cria simbologia com 1 linha de chamada
; I2 – cria simbologia com 2 linhas de chamada
;
(defun c:i1()
(progn
(setq p1 (getpoint “\nClique na peca: “))
(setq p2 (getpoint “\nClique na posicao da bola do item: “))
(setq colorold (getvar “cecolor”))
(setvar “cecolor” “7”)
(command “line” p1 p2 “ ”)
(setvar “cecolor” “1”)
(command “circle” p2 “4”)
(command “trim” “ “ p2 “ “)
(setvar “cecolor” “7”)
(command “donut” “0” “2” p1 “ “)
(setq t1 (getstring “\nEntre com o texto: “))
(command “text” “s” “standard” “m” p2 “3.5” “0” t1)
(setvar “cecolor” colorold)
)
)

(defun c:i2()
(progn
(setq p1 (getpoint “\nClique na peca: “))
(setq p11 (getpoint “\nClique num ponto intermediario: “))
(setq p2 (getpoint “\nClique na posicao da bola do item: “))
(setq colorold (getvar “cecolor”))
(setvar “cecolor” “7”)
(command “line” p1 p11 p2 “ ”)
(setvar “cecolor” “1”)
(command “circle” p2 “4”)
(command “trim” “ “ p2 “ “)
(setvar “cecolor” “7”)
(command “donut” “0” “2” p1 “ “)
(setq t1 (getstring “\nEntre com o texto: “))
(command “text” “s” “standard” “m” p2 “3.5” “0” t1)
(setvar “cecolor” colorold)
)
)

(alert “Foram criados os comandos de itemizar I1=1 linha, I2= 2 linhas”)

Exemplo 3 – Rotina para criar sequencia de numeros

É comum em alguns desenhos, como em desenhos elétricos, a necessidade de gerar uma sequencia
de números espaçados uniformemente e muma ordem crescente ou decrescente. Isto ocorre em desenhos de
bornes, ligação de fios, etc..

A rotina que segue permite que estes números sejam criados de forma fácil, em ordem crescente, na
horizontal, na vertical, etc..

;
; Arquivo: NUMERA.LSP
;
; Esta rotina permite que se escreva automaticamente uma sequencia
; de numeros inteiros. Isto e muito util, por exemplo, em desenhos
; eletricos
;
(princ “\nSequencia de numeros inteiros em desenho”)
(princ “\nNumero inteiro incial: “)
(setq inicial (getint))
(princ “\nNumero inteiro final: “)
(setq final (getint))
(princ “\nPasso-intervalo entre um numero e outro: “)
(setq passo (getint))
(setq dx(getreal “\nDefina a distancia em X dos numeros: “))
(setq dy(getreal “\nDefina a distancia em Y dos numeros: “))
(setq origem (getpoint “\Defina o ponto inicial da lista: “))

(setq conteudo (itoa inicial))

(command “text” “S” “standard” origem “3” “0” conteudo)

(setq contador inicial)

(while (<= contador final)
(setq origem(list (+ (car origem) dx) (+ (cadr origem) dy)))
(setq contador (+ contador passo))
(setq conteudo (itoa contador))
(command “text” “s” “standard” origem “3” “0” conteudo)
)

Exemplo 4 – Rotina para gerar malha sobre curvas de nível

Uma opção realmente muito interessante quando se tem as curvas de nível de um terreno, é gerar
sobre o mesmo uma malha, que permita Ter uma noção espacial, dando assim uma noção real.

Observe exemplo que segue. A esquerda temos um conjunto de curvas de nível no plano e a direita
a malha gerada já renderizada. Observe que há um aumento sem precedentes do nível de entendimanto até
mesmo para leigos. Portanto, se você usa este tipo de projeto, esta rotina poderá ser útil.

Filgura

;
; Arquivo: MALHA.LSP
;

; Esta rotina cria uma malha sobre as curvas de nivel, gerando assim uma impresao
; realistica do relevo desejado
;
; Concideracoes: - as curvas deverao estar cada uma em sua respectiva altura e numa vista de topo
; - sera gerada uma malha poligonal com uso de 3dmesh no layer malha
; - para visualizar o relevo use ddvpoint ou outro commando de visualizacao

; setagens iniciais
(setq colorold (getvar “cecolor”))
(setq layerold (getvar “clayer”))
(setq apertold (getvar “aperture”))

(setq W (getdist “\nEntre com largura de cada unidade da malha: “))

(setq P1 (getpoint “\nPick um ponto retangular de inicio a malha: “))
(setq P3 (getpoint “\nPick ponto oposto da malha: “))
(setq P2 (list (car P1) (cadr P3)))
(setq P4 (list (car P3) (cadr P1)))
(setq dx (distance P1 P4))
(setq dy (distance P1 P2))
(setq nx (fix (/ dx w)))
(setq ny (fix (/ dy w)))
(command “layer” “n” “malha” “s” “malha” “ “)
(command “pline” p1 p2 p3 p4 “c”)
(command “osnap” “nea”)
(comand “aperture” ”50”)

; desenha linhas em x para interpolacao

(setq x1 0)
(setq y1 0)
(setq pt p1)
(while (< x1 nx)
(progn
(setq px pt)
(setq px (list (+ (car px) w) (cadr px)))
(setq px1 px)
(setq pt (list (+ (car pt) w) (cadr pt)))
(setq x1 (+ x1 1))
(setq y1 0)
(while (< y1 ny)
(progn
(setq temp px1)
(setq px1(list (car px1) (+ (cadr px1) w)))
(setq px temp)
(command “line” px px1 “ “)
(setq y1 (+ y1 1))
)
)
)
)
(command “redraw”)

; desenha linhas em y para interpolacao

(command “aperture” “50”)
(setq x1 0)
(setq y1 0)
(setq pt p1)
(while (< y1 ny)
(progn
(setq py pt)
(setq py (list (car py) (+ (cadr py) w) ))
(setq py1 py)
(setq pt (list (car pt) (+ (cadr pt) w) ))
(setq y1 (+ y1 1))
(setq x1 0)
(while (< x1 nx)
(progn
(setq temp py1)
(setq py1(list (+ (car py1) w) ( cadr py1)))
(setq py temp)
(command “line” py py1 “ “)
(setq x1 (+ x1 1))
)
)
)
)
(command “redraw”)

; determina os pontos de recobrimento

(command “aperture” “50”)
(command “color” “2”)
(command “layer” “n” “malha” “s” “malha” “ “)
(setq malhafile (open “malha.scr” “w”))
(write-line “3dmesh” malhafile)
(write-line (rtos ny 2 0) malhafile)
(write-line (rtos nx 2 0) malhafile)
(setq x1 0)
(setq y1 0)
(setq pt (list (- (car p1) w) (- (cadr p1) w) (caddr p)))
(while (< y1 ny)
(progn
(setq py pt)
(setq py (list (car py) (+ (cadr py) w) ))
(setq py1 py)
(setq pt (list (car pt) (+ (cadr pt) w) ))
(setq y1 (+ y1 1))
(setq x1 0)
(while (< x1 nx)
(progn
(setq temp py1)
(setq py1(list (+ (car py1) w) (cadr py1)))
(setq py temp)
(command “id” py1)
(setq ponto (getvar “lastpoint”))
(write-line (strcat (rtos (car py1)) “,” (rtos (cadr py1)) “,” (rtos (caddr ponto)) malhafile)
(setq x1 (+ x1 1))
)
)
)
)
(write-line (strcat “color” colorold) malhafile)
(write-line (strcat “layer” “s” layerold “ “) malhafile)
(write-line (strcat “aperture “ (rtos apertold 2 0)) malhafile)
(close malhafile)
(command “osnap” “ “)
(setq sset (ssget “x” (list (cons 8 “malha”))))
(command “erase” sset “ “)
(command “script” “malha.scr”)

Fases do processo de uso da rotina MALHA.LSP:

1) Desenhe as curvas de nível. Você poderá usar qualquer tipo de objeto para isso: linhas, polilinhas,
splines, etc..

2) Posicione cada curva em sua respectiva altitude. A definição da altitude de cada curva é que definirá
com será o relevo. A figura que segue mostra as curvas anteriores já posicionadas em suas respectivas
altitudes, numa visão em perspectiva.

3) Volte a uma vista da imagem. A mesma deverá ficar de forma que todas as curvas fiquem dentro da área
gráfica do AutoCAD.

4) Carregue a rotina. Você será solicitado a entrar com os seguintes dados.

Entre com largura de cada unidade da malha:

Pick um ponto retangular da inicio da malha:
Pick ponto opesto da malha:

5) Aguarde a execução da rotina. Durante a execução, você perceberá que são geradas linha de interpolação
como na figura que segue. Quanto maior a área da malha e quanto menor o retângulo de cada unidade da
malha, maior o tempo de processamento.

6) Acerto do layer e entidades. A malha será gerada no layer MALHA, na cor amarela e com a aparência
apresentada a seguir. Altere a cor e o layer para o que julgar necessário.

7) Escolha um ponto de vista adequado. Após gerada a malha no layer MALHA, você poderá visualizá-la
de um ângulo em perspectiva para melhor entende-la.