Neste post, veremos o método mais poderoso disponível para “não programadores” para personalizar BricsCAD - a linguagem de programação LISP. Nesta postagem, aprenda os primeiros passos necessários para escrever sua rotina LISP.

Para uma visão geral completa dos comandos LISP para BricsCAD, você pode visualizar o arquivo oficial, BricsCAD LISP Developer Guide.


Os seguintes tópicos são abordados neste artigo:


POR QUE ESCREVER UM PROGRAMA?

Se você é como muitos usuários de CAD, está ocupado criando desenhos e não tem tempo para aprender a escrever programas de software. Sem dúvida, você pode estar se perguntando: "Por que se preocupar em aprender uma linguagem de programação?" De certa forma, é como voltar à escola. Sentar na sala de aula às vezes parece uma perda de tempo.

Mas as coisas que você aprende agora facilitam a vida mais tarde. Aprender alguma programação LISP agora significa que você se sentirá muito bem ao usar algumas linhas de código para permitir que o LISP execute tarefas tediosas para você. O bom do LISP é que você pode programá-lo rapidamente. E pode usá-lo depois, para tarefas realmente simples mas tediosas.

ATENÇÃO: Este artigo no Blog é transcrito aqui no idioma Português-Brasil, mas pelo fato do artigo original ter sido escrito em Inglês, é possível que algumas instruções (especialmente: códigos) possam gerar conflito entre os idiomas. Sugiro consultar também os códigos de origem (no livro ou na versão em inglês deste post) para garantir que seu trabalho esteja bem resolvido.

Aqui está o exemplo que usaremos para este tutorial:

O comando Id

BricsCAD tem o comando Id . Quando você escolhe um ponto na tela, o Id relata as coordenadas 3D x, y, z do ponto. O problema é, Id relata o valor na área do prompt de comando, assim:

: id
Selecionar um ponto para identificar coordenadas: (Escolha um ponto.)
X = 8,9227 Y = 6,5907 Z = 0,0000

Não seria ótimo se você pudesse mudar Id para que ele coloque as coordenadas no desenho, próximo ao ponto de seleção? Isso permitiria que você identificasse coordenadas x, y e elevações z em um plano de site. Com o LISP você pode.

O PLANO DE ATAQUE

Antes de escrever qualquer código LISP, você precisa descobrir como obter essas coordenadas x, y, z na área do prompt de comando e no desenho. Reconheça que existem duas partes para resolver o problema:

Parte 1. Obter as coordenadas do desenho, provavelmente escolhendo um ponto.
Parte 2. Colocar as coordenadas como um texto no desenho.

Obter as Coordenadas

O LISP fornece várias maneiras de obter as coordenadas de um ponto escolhido. Navegando pela LISP Programming Language Reference (Referência da Linguagem de Programação LISP), você vai aprender que pode:

  • Usar o Id (comando) com a função comando , como em (command "ID").
  • Usar o LastPoint (variável de sistema) com o getvar , como em (getvar "lastpoint").
  • Usar o getpoint , como em (getpoint "Escolha um ponto: ")

Seria uma lição útil usar cada um dos três e depois ver o que acontece. Ao experimentar, você comete erros e depois aprende com os erros.

  1. Inicie o BricsCAD, carregue um desenho e alterne para a janela Histórico do prompt com F2. No prompt ':', digite:

    : (comandoID“)

    Aqui você está executando um comando BricsCAD (Id) de dentro de uma rotina LISP. A função "command" permite a
    você usar qualquer comando BricsCAD no LISP. O comando BricsCAD está entre aspas "ID" porque o comando é uma "string" (cadeia de caracteres no dialeto dos programadores para "texto"). Assim como antes, BricsCAD solicita que você indique o ponto no desenho.

  2. Em resposta à solicitação da rotina LISP, escolha um ponto:

    Selecione um ponto para identificar coordenadas: (Escolha um ponto.)
    X = 8,9227 Y = 6,5907 Z = 0,0000

  3. Desconhecido para você, BricsCAD sempre armazena as coordenadas x, y, z do último ponto selecionado em uma variável do sistema chamada LastPoint. Portanto, você deve copiar as coordenadas de LastPoint para uma variável que você vai criar. Precisa fazer isso porque as coordenadas no LastPoint são substituídas por outras no próximo uso de um comando que utiliza um ponto escolhido.
    Lembre-se deste capítulo que a função setq armazena valores em variáveis. Faça uso agora. No prompt ':', digite:

    : (setq xyz (getvar LastPoint“))
    (8.9227 6.5907 0.0000)

    • Xyz é o nome da variável na qual você armazena as coordenadas x, y, z.
    • Getvar é o nome da função LISP que recupera o valor armazenado em uma variável do sistema.
    • E "LastPoint”É o nome da variável do sistema; é cercado por aspas porque é um nome de variável do sistema (uma sequência).

    Depois de inserir a função LISP, BricsCAD retorna o valor armazenado na variável xyz, como (8.9227 6.5907
    0,0000) - seu resultado será diferente. Observe como as coordenadas estão entre parênteses. Isto é
    chamada de lista, pela qual o LISP é famoso (na verdade, LISP é a abreviação de "processamento de lista"). Os espaços separam os números, que são as coordenadas x, y, e z, respectivamente:

    x 8.9227
    y 6.5907
    z 0.0000

    BricsCAD sempre armazena os valores na ordem de x, y, e z. Você nunca encontrará a coordenada z primeiro ou a coordenada x por último.

Então, agora resolvemos o primeiro problema de uma maneira. Obtivemos as coordenadas do desenho e as armazenamos em uma variável. Mencionamos uma terceira função LISP que poderíamos usar, getpoint. Os programadores preferem getpoint porque é mais eficiente que o Id-LastPoint combinação que usamos acima.

Digite o seguinte para ver se funciona exatamente da mesma forma, a diferença é que fornecemos o texto do prompt ("Ponto: "):

: (setq xyz (getpoint "Ponto: "))
Ponto: (Escolha um ponto.)
(8.9227 6.5907 0.0000)

Como antes, usamos setq para armazenar o valor das coordenadas na variável xyz. O getpoint (função) espera que você escolha um ponto na tela. o "Ponto: " é chamado de um prompt (aviso), que informa ao usuário o que o programa espera que ele faça. Poderíamos facilmente escrever qualquer coisa, como:

: (setq xyz (getpoint “Pressione o botão do mouse:“))
Pressione o botão do mouse: (Escolha um ponto.)
(8.9227 6.5907 0.0000)

Ou, não poderíamos ter nenhum prompt, da seguinte maneira:

: (setq xyz (getpoint))
(Escolha um ponto.)
(8.9227 6.5907 0.0000)

Está certo. Então nenhum aviso. Apenas um BricsCAD silencioso esperando pacientemente a coisa certa acontecer ... e o usuário ficou intrigado com o motivo de nada estar acontecendo. Falta de comunicação, você pode dizer. É por isso que os avisos são importantes.

Vimos agora algumas abordagens que resolvem o mesmo problema de maneiras diferentes. Com as coordenadas x, y, z armazenadas com segurança em uma variável, vamos abordar o segundo problema.

COLOCANDO O TEXTO

Para colocar texto no desenho, podemos usar apenas o comando (função) em conjunto com o Text (comando). Suponho que MText pode funcionar, mas para uma linha de texto, o comando Text é excelente. o Text comando é, no entanto, mais complicado que o Id comando. Possui no mínimo quatro solicitações que sua rotina LISP deve responder:

: text
Texto: Estilo/Alinhar/Ajustar/Centro/Meio/Direita/Justificar/ :
Altura do texto <2>:
Angulo de rotação do texto <0>:
Texto:

Ponto de partida: um par de números, especificamente uma coordenada x, y.
Altura do texto: um número para tornar o texto legível.
Angulo de rotação do texto: um número, provavelmente 0 graus.
Texto: a string, no nosso caso, as coordenadas x, y, z.

Vamos construir uma função LISP para colocar as coordenadas x, y, z como texto:

(command "text" xyz 200 0 xyz)

(command é o comando (função).
"texto" é o BricsCAD Text (comando) sendo executado.
xyz variável que armazena o ponto de partida do texto.
200 é a altura do texto. Mude esse número para algo conveniente para seus desenhos.
0 é o ângulo de rotação do texto.
xyz significa que você tem sorte: o Text (comando) aceita números como texto.
) e lembre-se: precisa haver um parêntese de fechamento para cada parêntese de abertura.

Tente isso na linha do prompt:

: (command “text” xyz 200 0 xyz)
Texto: Estilo/Alinhar/Ajustar/Centro/Meio/Direita/Justificar/:
Altura do texto: 200
Angulo de rotação do texto: 0
Texto: 2958.348773815669,5740.821183398367
:

BricsCAD é executado através do Text , inserindo as respostas para seus prompts e colocando as coordenadas como texto. Resolvemos a segunda parte do problema.

JUNTAR AS PEÇAS

Vamos montar as duas soluções para o seu problema:

(setq xyz (getpoint “Escolha um ponto:“))
(command "text" xyz 200 0 xyz)

Aí está: um programa LISP completo. Bem, não exatamente. É cansativo digitar novamente essas duas linhas toda vez que você deseja marcar um ponto. Na próxima seção, você descobrirá como salvar o código como um .lsp (arquivo no disco). Você também vai vestir o código.

Adicionar ao Programa LISP Simples

O que você tem agora é o algoritmo - o núcleo de todo programa de computador que executa o trabalho real. O que falta é mais uma interface de usuário - a parte que facilita o uso do programa por qualquer usuário.

Tudo o que você tem para uma interface do usuário faz parte da primeira linha que solicita "Selecionar ponto para identificar coordenadas:". Existem muitos problemas na interface do usuário com este pequeno programa. Em quantos você consegue pensar? Aqui está uma lista dos problemas que me deparei:

  • É difícil digitar novamente essas duas linhas sempre que você quiser marcar um ponto - você precisa dar um nome ao programa…
  • … E você precisa salvá-lo no disco para não precisar digitar novamente o código a cada nova sessão BricsCAD…
  • … E, se você usa muito este programa LISP, deve ter uma maneira de carregá-lo automaticamente.
  • As coordenadas x, y, z são impressas com oito casas decimais; para a maioria dos usuários, isso é demais.
  • Você pode controlar a camada em que o texto é colocado.
  • Você pode querer um estilo de texto específico.
  • Certamente, você gostaria de ter algum controle sobre o tamanho e a orientação do texto.
  • Aqui está uma idéia ortogonal: armazene as coordenadas x, y, z em um arquivo no disco - caso você queira reutilizar os dados.

CONQUISTANDO OS RECURSOS

“Tudo bem”, você pode estar pensando, “eu posso concordar que essas são principalmente melhorias desejáveis. Vá em frente, Sr. Grabowski: mostre-me como adicioná-los.

Mas espere um minuto! Quando você não está familiarizado com o LISP, pode não perceber como uma interface do usuário adiciona uma quantidade enorme de código, o que significa mais erros e mais depuração. (Se você está familiarizado com a programação, sabe com que rapidez um programa simples se enche de inchaço dos recursos.) Embora todos esses recursos adicionados pareçam desejáveis, eles podem tornar o programa menos desejável. Você pode imaginar como ficaria irritado se tivesse que responder a perguntas sobre casas decimais, fonte de texto, tamanho do texto, orientação do texto, nome da camada, nome do arquivo - sempre que quisesse rotular um único ponto?

Dê uma segunda olhada na lista de desejos acima. Marque os recursos importantes para você e, em seguida, cruze os que você poderia viver sem.

Item #1 da lista de desejos: Nomeando o programa

Para dar um nome ao programa, coloque o código com a tecla defun e dê um nome a ele, da seguinte maneira:

(defun c:etiqueta ( / xyz)
(setq xyz (getpoint “Escolha um ponto:“))
(command "text" xyz 200 0 xyz)
)

Vamos dar uma olhada no que foi adicionado, peça por peça:

Definindo a Função - defun

(defun define o nome da função. No LISP, os termos: função, programa, e rotina são usados de forma intercambiável (defun é a abreviação de "define função".

Nomeando a Função - C:

c:etiqueta é o nome da função. Eu decidi chamar esse programa de "Etiqueta"; você pode chamá-lo como quiser, desde que o nome não entre em conflito com o de qualquer função LISP interna ou outra função definida pelo usuário. o C: (prefixo) faz com que essa rotina LISP apareça como um comando BricsCAD.

Para executar o programa Etiqueta, tudo que você precisa fazer é digitar “etiqueta” no prompt ':', assim:

: etiqueta
Selecionar um ponto para identificar coordenadas: (Escolha um ponto.)

Quando o C: (prefixo) estiver ausente, no entanto, você deverá executar o programa como uma função LISP, completa com parênteses, da seguinte maneira:

: (etiqueta)
Selecionar um ponto para identificar coordenadas: (Escolha um ponto.)

Variáveis Locais e Globais - /

( / xyz ) declara os nomes das variáveis, de entrada e local ; a barra separa as duas:

Variáveis de entrada (Input) - alimentam os dados para rotinas LISP; os nomes das variáveis de entrada aparecem antes da barra inclinada.
Variáveis locais (Local) - usadas somente dentro dos programas; os nomes das variáveis locais aparecem após a barra inclinada

Neste programa, xyz é o nome da variável usada estritamente no programa. Se a variável não for declarada local, ela se tornará global. O valor de uma variável global pode ser acessado por qualquer Função LISP carregada no BricsCAD.

O benefício de declarar variáveis como locais é que BricsCAD libera automaticamente a memória usada pela variável quando o programa LISP termina; a desvantagem é que o valor é perdido, dificultando a depuração. Por esse motivo, variáveis locais são mantidas globais até o programa ser depurado.

E o ) - parêntese de fechamento - equilibra o parêntese de abertura no início do programa.

Item #2 da lista de desejos: Salvar o programa

Ao salvar o programa em um arquivo no disco, você evita redigitar o código a cada nova sessão BricsCAD. Você faz isso da seguinte maneira:

  1. Inicie um editor de texto (o Bloco de Notas fornecido com o Windows ou o Text Edit com Linux e Mac são bons). Digite o código mostrado:

    (defun c: label (/ xyz)

    (setq xyz (getpoint “Escolha um ponto: “))
    (command “text” xyz 200 0 xyz)

    )

    Recuei o código no meio para destacá-lo da linha defun e do parêntese de fechamento. Isso é padrão entre programadores; os recuos facilitam a leitura do código. Você pode usar um par de espaços ou a tecla tab porque o LISP não se importa.

  2. Salve o arquivo com o nome Etiqueta.lsp na pasta BricsCAD.

Item #3 da lista de desejos: Carregar Automaticamente o Programa

Para carregar o programa no BricsCAD, digite o seguinte:

: (load "etiqueta")

Se o BricsCAD não conseguir encontrar o programa LISP, será necessário especificar o caminho. Supondo que você salvou etiqueta.lsp no \cad\support pasta, você digitaria: : (load "\\cad\\support\\etiqueta")

Agora tente usar a rotina para colocar um etiqueta nos pontos, da seguinte maneira:

: etiqueta
Selecionar um ponto para identificar coordenadas: (Escolha um ponto.)

DICA BricsCAD fornece uma maneira de carregar programas LISP automaticamente. Quando BricsCAD é inicializado, ele procura um arquivo chamado on_doc_load.lsp.lsp. BricsCAD carrega automaticamente os nomes dos programas LISP listados no arquivo.
Adicionar label.lsp a on_doc_load.lsp é fácil. Abra o arquivo on_doc_load.lsp com um editor de texto (se o arquivo não existir, inicie um novo arquivo chamado on_doc_load.lsp e armazene-o na pasta \ BricsCAD). Adicione o nome do programa: (carregue “label.lsp”) Salve o arquivo on_doc_load.lsp. Inicie o BricsCAD e ele deve carregar o rótulo automaticamente .——–

Adicionando etiqueta.lsp para on_doc_load.lsp é fácil. Abra o on_doc_load.lsp arquivo com um editor de texto (se o arquivo não existir, inicie um novo arquivo chamado acad.lsp e guarde-o no \ BricsCAD pasta). Adicione o nome do programa:

(load "etiqueta.lsp")

Salve o on_doc_load.lsp (arquivo). Inicie o BricsCAD e ele deverá carregar etiqueta automaticamente.

Lista de desejos #4: Usando Car e Cdr

As coordenadas x, y, z são impressas com oito casas decimais - isso é demais. Existem duas soluções.

Uma é perguntar ao usuário o número de casas decimais, como mostra o seguinte fragmento de código:

: (setq uprec (getint “Precisão da etiqueta:“))
Precisão da etiqueta: 1
1

Ou extraia o valor armazenado na variável de sistema LUPrec - a precisão especificada pelo usuário através do Unidades - comando - sob a suposição (não necessariamente verdadeira) de que o usuário deseja unidades consistentes. O código para fazer isso é o seguinte:

(setq uprec (getvar “LUPREC”))

Essa era a parte fácil. A parte difícil é aplicar a precisão às coordenadas x, y, z, que são três etapas: (1) separa o trigêmeo de coordenadas; (2) aplique o fator de precisão; e (3) unir as coordenadas. Aqui está como:

  1. Abra etiqueta.lsp no bloco de notas ou em outro editor de texto. Remova / xyz do código. Isso torna a variável "global", para que você possa verificar seu valor no prompt ':' de BricsCAD. O código deve ficar assim:

    (defun c:etiqueta ()

    (setq xyz (getpoint “Escolha um ponto:“))
    (command "text" xyz 200 0 xyz)

    )

  2. Salve e carregue etiqueta.lsp no BricsCAD.
  3. Execute etiqueta.lsp, escolhendo qualquer ponto na tela. Se você não vir as coordenadas impressas na tela, faça o zoom em extensão.
  4. No prompt ':', digite o seguinte:

    : !xyz
    (6.10049 8.14595 10.0)

    O ponto de exclamação força BricsCAD a imprimir o valor da variável xyz, que contém as coordenadas x, y, z. Seus resultados serão diferentes, dependendo de onde você escolheu.

  5. LISP possui várias funções para separar uma lista. Aqui você usa as funções car e cdr e suas combinações. A função car extrai o primeiro item (a coordenada x) de uma lista. Tente agora:

    : (car xyz)
    6.10049

  6. O cdr (função) é o complemento para car. Ela remove o primeiro item da lista e lhe entrega o que resta:

    : (cdr xyz)
    (8.14595 10.0)

  7. Além de car e cdr, O LISP permite combinar o "a" e o "d" de várias maneiras para extrair outros itens da lista. Para extrair a coordenada y, use cadr, do seguinte modo:

    : (cadr xyz)
    8.14595

  8. E para extrair a coordenada z, use caddr, do seguinte modo:

    : (caddr xyz)
    8.14595

  9. Agora eu tenho uma maneira de extrair a coordenada x, a coordenada y e a coordenada z da variável xyz. Vou armazená-los em suas próprias variáveis, da seguinte maneira:

    : (setq ptx (car xyz)
    Faltando: 1) > pty (cadr xyz)
    Faltando: 1) > ptz (caddr xyz)
    Faltando: 1) > )

    Você usa variável PtX para armazenar a coordenada x, PtY para a coordenada y, e assim por diante. Além disso, uma forma de atalho LISP foi usada no código acima, que permite aplicar a função setq a várias variáveis. Lembre-se do motivo do prompt 'Missing: 1) >' do BricsCAD: ele lembra que um parêntese de fechamento está ausente.

  10. Agora que as três coordenadas estão separadas, você pode finalmente reduzir o número de casas decimais. Há algumas maneiras de fazer isso. Use a função rtos , porque esta faz duas coisas ao mesmo tempo: (1) altera o número de casas decimais para qualquer número entre 0 e 8; e (2) converte o número real em uma string.
    Por que uma string? Você verá mais tarde. Por enquanto, aqui está a função rtos no trabalho:

    : (rtos ptx 2 uprec)
    “6.1”

    O rtos (função) usa três parâmetros: ptx, 2 e uprec.
    PtX Nome da variável que contém o número real.
    2 Tipo de conversão, decimal neste caso. O número 2 é baseado na variável do sistema LUnits, que define cinco modos de unidades:

    1. Científico
    2. Decimal
    3. Engenharia
    4. Arquitetônico
    5. Fracionário

    UPrec Nome da variável que contém a precisão (o código para isso está no início desta seção). Isso varia, dependendo do tipo de unidades. Por exemplo, um valor de 2 para decimal significa duas casas decimais; um 2 para arquitetura significa um quarto de polegada.
    Supondo, então, que a precisão em UPrec é 1, o rtos (função) no fragmento de código acima reduz 6.10049 para 6.1.

  11. Trunque e preserve os valores de x, y, e z três vezes, da seguinte maneira:

    : (setq ptx (rtos ptx 2 uprec)
    1> pty (rtos pty 2 uprec)
    1> ptz (rtos ptz 2 uprec)
    1> )

    Observe que você pode definir uma variável igual a si mesma: PtX mantém o novo valor da coordenada x depois que o rtos termina de processar o valor anterior armazenado em PtX. Reutilizar um nome de variável como essa ajuda a economizar memória.

  12. Com as coordenadas truncadas, você agora precisa colocá-las (perdoar o trocadilho) junto com o strcat (função), abreviação de concatenação de string. Tente agora:

    : (strcat ptx pty ptz)
    “6.18.110.0”

    É mais assim!

  13. Voltar ao editor de texto. Adicione o código que você desenvolveu aqui, mostrado em negrito, e com as funções LISP em roxo:

    (defun c:etiqueta ( / xyz xyz1 uprec ptx pty ptz)

    (setq uprec (getint “Precisão da etiqueta:“))
    (setq xyz (getpoint "Escolha um ponto: "))
    (setq ptx (car xyz)
    pty (cadr xyz)
    ptz (caddr xyz)
    )
    (setq ptx (rtos ptx 2 uprec)
    pty (rtos pty 2 uprec)
    ptz (rtos ptz 2 uprec)
    )
    (setq xyz1 (strcat ptx ", " pty ", " ptz))
    (comando “text” xyz 200 0 xyz1)

    (

  14. Observe que todas as variáveis são locais. Observe também a alteração na variável xyz nas duas últimas linhas: você não deseja que o texto seja colocado nas coordenadas arredondadas, portanto, use xyz1 como a variável que contém a string de texto.
  15. Por fim, você deve adicionar comentários ao seu código para lembrá-lo do que este faz quando você olhar para o código daqui a alguns meses. Os caracteres de ponto-e-vírgula indicam o início dos comentários:

    ; Etiqueta.Lsp coloca uma etiqueta num ponto selecionado, contendo suas coordenadas x, y, z.
    ; por Ralph Grabowski, 25 de fevereiro de 1996.
    (defun c:etiqueta (/ xyz xyz1 uprec ptx pty ptz)

    ; Pede ao usuário o número de casas decimais:
    (setq uprec (getint “Precisão da etiqueta:“))
    ; Pede ao usuário para escolher um ponto no desenho:
    (setq xyz (getpoint “Escolha um ponto:“))
    ; Separa o ponto 3D em valores individuais para x, y, z:
    (setq ptx (car xyz)
    pty (cadr xyz)
    ptz (caddr xyz)
    )
    ; Para truncar os valores:
    (setq ptx (rtos ptx 2 uprec)
    pty (rtos pty 2 uprec)
    ptz (rtos ptz 2 uprec)
    )
    ; Recombina os valores individuais em um ponto 3D:
    (setq xyz1 (strcat ptx ", " pty ", " ptz))
    ; Colocar o texto:
    (command “text” xyz 200 0 xyz1)

    )

  16. Salve o arquivo como etiqueta.lsp e carregue a rotina LISP no BricsCAD com:

    : (loadetiqueta“)
    "C:ETIQUETA"

  17. Execute a rotina e responda às solicitações: ”

    : etiqueta
    Precisão da etiqueta: 1
    Escolher ponto: (Escolha um ponto.)
    texto Justificar…/ :
    Altura do texto <200.0000>: 200
    Angulo de rotação do texto <0>: 0
    Texto: 5012.3, 773.2, 0.0
    :

Salvando dados em arquivos

No tutorial anterior, começamos a nos preocupar com aprimoramentos da interface do usuário. O que começou como duas linhas de código agora aumentou para 23. Neste tutorial, aprendemos como combater o inchaço dos recursos (mais tarde) e adicionamos a capacidade de salvar dados em um arquivo.

Um leitor me escreveu com este item da lista de desejos: “O arquivo LISP é muito útil com alguns dos programas que eu uso, mas gostaria de poder salvar os dados coletados nas coordenadas x, y, z em um arquivo de texto."

Salvar os dados em arquivo é feito facilmente com as funções open, write-line, e close . Vamos dar uma olhada em como fazer isso. Lidar com arquivos no LISP é mais simples do que na maioria das linguagens de programação, porque o LISP possui funções de acesso a arquivos muito fracas. Tudo o que este pode fazer é ler e gravar arquivos ASCII em ordem sequencial; O LISP não pode lidar com arquivos binários nem acessar dados em ordem aleatória.

OS TRÊS PASSOS

Existem três etapas para gravar dados em um arquivo:

Passo 1. Abrir o arquivo.
Passo 2. Escrever os dados para o arquivo.
Etapa 3. Fechar o arquivo.

Etapa 1: Abrir o Arquivo

LISP tem a função open para abrir arquivos. A função permite abrir arquivos para 1 de três propósitos: (1) ler dados do arquivo; (2) gravar dados no arquivo; ou (3) anexar dados ao arquivo. Você deve escolher um desses de cada vez; O LISP não pode executar os três ao mesmo tempo.

Em todos os casos, o LISP se encarrega de criar o arquivo se ele ainda não existir. Ler dados é fácil de entender, mas qual é a diferença entre "gravar" e "anexar" dados?

  • Quando solicito ao BricsCAD para abrir um arquivo para write, todos os dados existentes nesse arquivo são apagados, e os novos dados são adicionados.
  • Quando solicito ao BricsCAD para abrir um arquivo para append, os novos dados são adicionados até o final dos dados existentes.

Para nosso propósito, queremos continuar adicionando dados ao arquivo, então escolha o modo append . O código LISP fica assim:

(setq FIL (open "xyzdata.txt" "a“))

Aqui você está definindo algo (através de setq) igual a uma variável chamada FIL. O que é isso? Em praticamente todas as linguagens de programação, não lidamos diretamente com o nome do arquivo, mas lidamos com um descritor de arquivo. Este é um nome (alguma sequência de letras e números) ao qual o sistema operacional atribui o nome do arquivo. Agora que você tem o descritor de arquivo armazenado na variável FIL, você trabalha com FIL, não o nome do arquivo, que decidi chamar xyzdata.txt.

O final "a" diz ao LISP que você deseja abrir xyzdata.txt para anexar dados. As opções para o open função são:

"a" Anexa dados ao final do arquivo.

"w" Grava dados no arquivo (apaga dados existentes).

"r" Lê dados do arquivo.

Etapa 2: Gravar Dados no Arquivo

Para gravar dados em arquivos, use a função write-line . Esta função grava uma linha de dados por vez.

(Outra função, a write , escreve isolados caracteres para arquivos.) O código se parece com o seguinte:

(write-line xyz1 fil)

Você não pode, no entanto, apenas gravar dados brutos no arquivo, porque eles teriam três casas decimais e muitos dígitos, como este:

8.15483.27520.0000

A maioria dos softwares é capaz de ler dados com vírgulas que separam números, assim:

8.1548, 3.2752, 0.0000

Isso inclui planilhas, programas de banco de dados e até mesmo algum software de processamento de texto. Digo a esses programas que, quando lêem os dados, devem considerar a vírgula como um separador e não uma vírgula. Dessa forma, o programa de planilha coloca cada número em sua própria célula. Com cada número em sua própria célula, eu posso manipular os dados. Por esse motivo, você precisa de um código que formate os dados.

Felizmente, você já fez isso. No último tutorial, você usou o strcat função junto com o cdr, cadr, e caddr funções para separar os componentes x, y, e z do trigêmeo de coordenadas. Então você pode reutilizar o código, que se parece com isso:

(setq ptx (car xyz)
pty (cadr xyz)
ptz (caddr xyz)
)
(setq xyz1 (strcat ptx ", " pty ", " ptz))

O strcat (função) coloca as vírgulas entre os valores das coordenadas.

Etapa 3: Fechar o arquivo

Por fim, para fins de boa limpeza, feche o arquivo. O BricsCAD fechará automaticamente o arquivo para você, se você esquecer, mas um bom programador limpa seu código. Fechar o arquivo é tão simples quanto:

(close fil)

JUNTAR AS PEÇAS

Adicione o código para abrir, formatar, escrever e fechar no arquivo lable.lsp programa:

(defun c:etiqueta (/ xyz xyz1 uprec ptx pty ptz)

(setq uprec (getint “Label precision:“))
(setq xyz (getpoint “Pick point:“))
(setq ptx (car xyz) pty (cadr xyz)
ptz (caddr xyz))
; Formate as coordenadas x, y, z:
(setq ptx (rtos ptx 2 uprec)
pty (rtos pty 2 uprec)
ptz (rtos ptz 2 uprec))
; Adicione vírgulas entre as três coordenadas:
(setq xyz1 (strcat ptx "," pty "," ptz))
; Escreva coordenadas no desenho:
(command “text” xyz 200 0 xyz1)
; Abra o arquivo de dados para anexar:
(setq fil (open "xyzdata.txt" "a"))
; Escreva a linha de dados no arquivo:
(write-line xyz1 fil)
; Feche o arquivo:
(close fil)

)

Usando um editor de texto, como o Bloco de Notas, faça as adições à sua cópia do lable.lsp. Carregue-o no BricsCAD com a load função:

: (load "etiqueta")

E execute o programa digitando Etiqueta na linhas de prompt:

: etiqueta
Precisão da etiqueta: 4
Escolher ponto: (Escolha um ponto.)

À medida que você seleciona pontos na tela, a rotina rotula os pontos selecionados, mas também grava os dados dos pontos 3D no arquivo. Depois de um tempo, é assim que o arquivo de dados se parece com isso:

8.1548, 3.2752, 0.0000
7.0856, 4.4883, 0.0000
6.4295, 5.6528, 0.0000
5.5303, 6.7688, 0.0000
5.4331, 8.3215, 0.0000

Lista de desejos #5: Camadas

Vamos reservar um momento para revisitar a lista de desejos. Um item da lista de desejos é controlar a camada na qual o texto é colocado. Há duas maneiras de abordar este item da lista de desejos:

  • O método sem código é definir a camada antes de iniciar a função LISP.
  • A versão com código LISP é solicitar ao usuário o nome da camada, e usar a função setvar para definir a variável do sistema CLayer (muito mais fácil do que usar o comando Camada), da seguinte maneira:

    (setq lname (getstring "Etiquetar camada:"))
    (setvar "CLAYER" lname)

    Adicione essas duas linhas antes da linha com o prompt "Escolher ponto".

Lista de desejos #6: Estilo do texto

Para especificar o estilo do texto, existem os mesmos dois métodos. O método sem código é simplesmente definir o estilo do texto antes de iniciar a rotina. Caso contrário, você pode escrever um código LISP semelhante para definir o estilo com o setvar comando, como segue:

(setq tsname (getstring "Estilo do texto da etiqueta: "))
(setvar "TEXTSTYLE" tsname)

Mais uma vez, adicione essas duas linhas antes da linha com o prompt "Escolher ponto".

Até agora, você deve estar percebendo que seu programa está começando a parecer grande. Isso é chamado de "inchaço dos recursos". Mais recursos, especialmente na área da interface do usuário, fazem com que o software cresça muito além do tamanho de seu algoritmo básico.

O Que vem a Seguir?

Para concluir o capítulo da seção LISP, darei 7 dicas para ajudar você a escrever suas funções LISP.


Download Grátis do BricsCAD por 30 dias

Comece a usar o BricsCAD hoje

Licenças permanentes ou por aluguel, que funcionam em todos os idiomas, em todas as regiões.


  1. Introdução
  2. 55 Dicas para Usuários do BricsCAD
  3. Configurações
  4. Mudar o Ambiente
  5. Interface de Usuário Personalizada
  6. Introdução ao Diálogo Personalizar
  7. Personalizar a barra de Menus & Menus de Contexto
  8. Barras de ferramentas e ícones de botão
  9. Escrever Macros e o Código Diesel
  10. Painéis e guias da faixa de opções
  11. Atalhos de teclas, aliases e comandos do shell
  12. Botões do mouse, clique duplo e tablet
  13. Absolutamente tudo o que você precisa saber sobre o Quad
  14. Propriedades de sobreposição
  15. Áreas de trabalho e a interface do usuário
  16. Projetando Painéis de Ferramentas e Estrutura
  17. Criando tipos de linha simples e complexos
  18. Padronizar Hachuras
  19. Decodificação de formas e fontes
  20. Codificação com texto do campo
  21. Escrevendo scripts
  22. Programando com LISP (Introdução)
  23. Funções LISP
  24. Escrevendo um Programa LISP Simples