Exemplo 1: Comandos criados pelo usuário:

Este exemplo mostra o conteúdo de um arquivo AutoLISP em que foram criados

comandos particulares para auxiliar o usuário. De maneira similar, você poderá criar seus
próprios comandos.

Estes comandos podem estar num arquivo chamado, por exemplo de

zcomandos.LSP. O método de criá-lo é bem simples, basta digita-lo usando um editor
qualquer e salvá-lo no modo texto, sem caracteres especiais.

;
; Costumização para teclados para AutoCAD
;
; Atalho para comandos permanentes 1x
;
(defun c:11() (command "osnap" "end,int,cen") (princ))
(defun c:12() (command "osnap" "") (princ))
(defun c:10()
(progn
(command "cmdecho" 0)
(setvar "FILLETRAD" 0)
(command "fillet")
(princ)))

(defun c:14()
(setvar "ATTDIA" 1)
(command "insert" "j:/produto/bib/formatos/form_plan_orcament.dwg"
"0,0,0" "" "" "") (command "zoom" "0,0" "210,297")
(princ))
(defun c:15() (setvar "APERTURE" 4) (setvar "PICKBOX" 4) (setvar
"CURSORSIZE" 100) (princ))
;
; COMANDOS DE SETAGEM DE COR 2x
;
(defun c:21() (command "color" "1") (princ))
(defun c:22() (command "color" "2") (princ))
(defun c:23() (command "color" "3") (princ))
(defun c:24() (command "color" "4") (princ))
(defun c:25() (command "color" "5") (princ))
(defun c:26() (command "color" "6") (princ))
(defun c:27() (command "color" "7") (princ))
(defun c:28() (command "color" "8") (princ))
(defun c:29() (command "color" "bylayer") (princ))
;
; COMANDOS DE TROCA DE COR 3x
;
(defun c:31() (princ "\nSelecione objetos para mudar cor para RED: ")
(command "select" "auto" pause)
(command "chprop" "p" "" "c" "1" "") (princ))
(defun c:32() (princ "\nSelecione objetos para mudar cor para YELLOW: ")
(command "select" "auto" pause)
 (command "chprop" "p" "" "c" "2" "") (princ))
(defun c:33() (princ "\nSelecione objetos para mudar cor para GREEN: ")
(command "select" "auto" pause)
(command "chprop" "p" "" "c" "3" "") (princ))
(defun c:34() (princ "\nSelecione objetos para mudar cor para CYAN: ")
(command "select" "auto" pause)
(command "chprop" "p" "" "c" "4" "") (princ))
(defun c:35() (princ "\nSelecione objetos para mudar cor para BLUE: ")
(command "select" "auto" pause)
(command "chprop" "p" "" "c" "5" "") (princ))
(defun c:36() (princ "\nSelecione objetos para mudar cor para MAGENTA: ")
(command "select" "auto" pause)
(command "chprop" "p" "" "c" "6" "") (princ))
(defun c:37() (princ "\nSelecione objetos para mudar cor para WHITE: ")
(command "select" "auto" pause)
(command "chprop" "p" "" "c" "7" "") (princ))
(defun c:39() (princ "\nSelecione objetos para mudar cor para BYLAYER: ")
(command "select" "auto" pause)
(command "chprop" "p" "" "c" "bylayer" "") (princ))
;
; COMANDOS DE SETAGEM DE TIPO DE LINHA 4X
;
(defun c:41() (command "linetype" "s" "continuous" "") (princ))
(defun c:42() (command "linetype" "s" "hidden" "") (princ))
(defun c:43() (command "linetype" "s" "dashdot" "") (princ))
(defun c:44() (command "linetype" "s" "center" "") (princ))
(defun c:49() (command "linetype" "s" "bylayer" "") (princ))
;
; COMANDOS DE TROCA DE LAYER 5x
;
(defun c:51()
(command "layer" "n" "conj" "c" "7" "conj" "")
(princ "\nSelecione objetos para mudar layer para CONJ: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "conj" "lt" "bylayer" "") (princ))
(defun c:52()
(command "layer" "n" "invis" "c" "3" "invis" "lt" "hidden" "invis" "")
(princ "\nSelecione objetos para mudar layer para INVIS: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "invis" "lt" "bylayer" "") (princ))
(defun c:53()
(command "layer" "n" "dim" "c" "2" "dim" "")
(princ "\nSelecione objetos para mudar layer para DIM: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "dim" "lt" "bylayer" "") (princ))
(defun c:54()
(command "layer" "n" "cl" "c" "4" "cl" "lt" "center" "cl" "")
(princ "\nSelecione objetos para mudar layer para CL: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "cl" "lt" "bylayer" "") (princ))
(defun c:55()
(command "layer" "n" "corte" "c" "5" "corte" "lt" "phantom2" "corte"
"")
(princ "\nSelecione objetos para mudar layer para CORTE: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "corte" "lt" "bylayer" "") (princ))
(defun c:56()
(command "layer" "n" "chapa" "c" "6" "chapa" "")
(princ "\nSelecione objetos para mudar layer para CHAPA: ") (command
"select" "auto" pause)
 (command "chprop" "p" "" "LA" "chapa" "lt" "bylayer" "") (princ))
;
; COMANDOS DE TROCA DE LAYER 6X
;
(defun c:61()
(command "layer" "n" "m01" "c" "1" "m01" "")
(princ "\nSelecione objetos para mudar layer para M01: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "m01" "lt" "bylayer" "") (princ))
(defun c:62()
(command "layer" "n" "m02" "c" "2" "m02" "")
(princ "\nSelecione objetos para mudar layer para M02: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "m02" "lt" "bylayer" "") (princ))
(defun c:63()
(command "layer" "n" "m03" "c" "3" "m03" "")
(princ "\nSelecione objetos para mudar layer para M03: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "m03" "lt" "bylayer" "") (princ))
(defun c:64()
(command "layer" "n" "m04" "c" "4" "m04" "")
(princ "\nSelecione objetos para mudar layer para M04: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "m04" "lt" "bylayer" "") (princ))
(defun c:65()
(command "layer" "n" "m05" "c" "5" "m05" "")
(princ "\nSelecione objetos para mudar layer para M05: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "m05" "lt" "bylayer" "") (princ))
(defun c:66()
(command "layer" "n" "m06" "c" "6" "m06" "")
(princ "\nSelecione objetos para mudar layer para M06: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "m06" "lt" "bylayer" "") (princ))
(defun c:67()
(command "layer" "n" "m07" "c" "7" "m07" "")
(princ "\nSelecione objetos para mudar layer para M07: ") (command
"select" "auto" pause)
(command "chprop" "p" "" "LA" "m07" "lt" "bylayer" "") (princ))
;
; Ajuda para o usuario
;
(defun c:h1()
(alert "Ajuda ao usuario:\n Os comandos criados pelo usuario
sao:\n 11 e 12 -altera o osnap\n 10 -fillet r0 \n 14 -insere
formplan1\n 2x -seta cor\n 3x -modif. cor\n 4x -seta tipo linha\n 5x
-muda a layer CONJ, INVIS, DIM, etc\n 6x -muda layer M01,M02, etc")
(princ))

Se o usuário precisar de um auxilio, basta digitar h1 no prompt do AutoCAD e a

caixa de diálogo da figura 8 aparecerá.

Observe que o sinal “;” permite a inserção de comentá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 item e qual
texto deseja acrescentar. Veja figura abaixo.

Figura 9 – A figura acima mostra o resultado do comando após sua utilização.

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 adaptar à 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
(command "cmdecho" "0")
(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" "1" p1 "")
(setq t1 (getstring "\nEntre com o texto: "))
(command "text" "s" "romans" "m" p2 "3.5" "0" t1)
(setvar "cecolor" colorold)
(command "redraw")
)
(princ))

(defun c:i2()
(progn
(command "cmdecho" "0")
(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" "1" p1 "")
(setq t1 (getstring "\nEntre com o texto: "))
(command "text" "s" "standard" "m" p2 "3.5" "0" t1)
(setvar "cecolor" colorold)
(command "redraw")
)
)

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

Figura 10 - Quando você entra o comando, a mensagem acima aparece na tela.

Exemplo 3 – Rotina para criar sequencia de numeros

É comum em alguns desenhos, como em desenhos elétricos, a necessidade de gerar

uma seqüência de números espaçados uniformemente e numa 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..

Veja como é fácil desenhar uma seqüência de números fornecendo apenas alguns valores
como: distância entre os números, o numero inicial e final, o passo e um ponto para o
inicio.

Command: num [chamada do comando no AutoCAD]

Seqüência de números inteiros em desenho [mensagem ao usuário]
Numero inteiro inicial: 1
Numero inteiro final: 9
Passo-intervalo entre um numero e outro: 1
Defina a distancia em X dos números: 5
Defina a distancia em Y dos números: 5
Defina o ponto inicial da lista:

Command:
Command: NUM
Seqüência de números inteiros em desenho
Numero inteiro inicial: 2
Numero inteiro final: 9
Passo-intervalo entre um numero e outro: 1
Defina a distancia em X dos números: 5
Defina a distancia em Y dos números: 0
Defina o ponto inicial da lista: [clique na tela para definir o inicio da numeração]

;
; Arquivo: NUMERA.LSP
;
; Esta rotina permite que se escreva automaticamente uma seqüência
; de números inteiros. Isto e muito útil, por exemplo, em desenhos
; elétricos
;
(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 entendimento 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..

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.

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

3) 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 oposto da malha:

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

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.

6) 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.

101
0101010101010101010101010101010101010101010101010101010101010101010101010
1010101010101010101010101010101010101010101010101010101010101010101010101
01010101010101010101010101010101010101010