Aula 26–Operadores de Comparação

Olá pessoal, hoje começaremos a dar inicio a matéria de tomada de decisões, porem antes precisamos aprender os operadores de comparação e na proxima aula aprenderemos os operadores lógicos, eles são de fácil entendimento e a única coisa que precisamos sempre lembrar é que os operadores lógicos e os operadores de comparação só retomam dois tipos de valores para o programa:

Nil = false

T = verdadeiro

Toda vez que um operador retornar nil é que a comparação é falsa, se o retorno for T (true) o operador será verdadeiro.

Abaixo segue a lista dos operadores lógicos e alguns exemplos:

Operadores de Comparação:

= (Igual) ou eq (igual)

Verifica se um ou mais elementos são iguais

(= 100 100) retorna T      OU      (eq 100 100) retorna T

(= “a” “a”) retorna T      OU      (eq “a” “a”) retorna T

(= “A” “a”) retorna nil      OU      (eq “A” “a”) retorna nil

(= 10 30) retorna nil      OU      (eq 10 30) retorna nil

(= 100 (* 50 2)) retorna T      OU      (eq 100 (* 50 2)) retorna T

 

/= (Diferente)

Verifica se um ou mais elementos são diferentes.

(/= 100 100) retorna nil

(/= “a” “a”) retorna nil

(/= “A” “a”) retorna T

(/= 10 30) retorna T

(/= 100 (* 50 2)) retorna nil

 

> (Maior)

Verifica se um elemento é maior do que o outro.

(> 100 50) retorna T

(> 2 100) retorna nil

(> 30 (- 40 10)) retorna nil (o resultado é igual, portanto não é maior).

(> (+ 10 10) (+ 5 4)) retorna T

 

< (Menor)

Verifica se um elemento é menor do que o outro.

(< 100 50) retorna nil

(< 2 100) retorna T

(< 30 (- 40 10)) retorna nil (o resultado é igual, portanto não é menor).

(< (+ 10 10) (+ 5 4)) retorna nil

 

>= (Maior ou igual)

Verifica se um elemento é maior ou igual ao outro.

(>= 100 50) retorna T

(>= 2 2) retorna T

(> 30 (- 40 10)) retorna T

(>= (+ 10 10) (+ 5 4)) retorna T

 

<= (Menor ou igual)

Verifica se um elemento é menor ou igual ao outro.

(<= 100 50) retorna nil

(<= 2 2) retorna T

(<= 30 (- 40 10)) retorna T

(<= (+ 10 10) (+ 5 4)) retorna nil

 

Equal (Equivalente)

Essa função verifica se dois elementos são iguais, diferente dos demais operadores esse operador pode verificar a igualdade entre duas listas.

(equal 20 20 ) retorna T

(equal 20 10) retorna nil

(equal “a” “a”) retorna T

(equal (list 1 2 3) (list 1 2 3)) retorna T

(equal (list “a” “b”) (list “b” “a”)) retorna nil

Diferente das demais a função EQUAL aceita um tolerância para isso devemos informar o valor dessa tolerância.

(setq a 123.3456)

(setq b 123.3457)

(equal a b) retornara nil

(equal a b 0.0001) retornara T

O mesmo acontecera com listas mais complexas.

(setq lista1 (list 10.1 20.1 30.4 25.6))

(setq lista2 (list 10 20 30.3 25.7))

(equal lista1 lista2 0.1) retornara T

Na próxima aula falaremos sobre os operadores lógicos.

Abaixo segue o link dessa vídeo-aula no meu canal manual de Cad no youtube.

https://www.youtube.com/watch?v=rxDq_yJ8BLE&feature=youtu.be

Espero que tenham gostado.

Sérgio Fernandes

Manual de Cad 

Aula 25–Tratamento de Erros

 

Olá pessoal, algumas aulas atrás aprendemos como guardas as variáveis de sistemas e como restaura-las no final do nosso programa, isso se torna muito útil, pois não alteramos o ambiente de trabalho que estava ativo antes da execução do programa, porem isso apenas funciona se o programa tiver um começo um meio e um fim, caso o programa for cancelado durante sua execução ou algum erro de programação aconteça o programa não vai restaurar as variáveis de sistema, para contornar esse problema aprenderemos hoje como alterar a função de erro do AutoCAD, dessa forma quando um erro acontecer podemos informar quais ações devem ser executas e assim garantir que as variáveis de sistemas sejam novamente restauradas.

Variável *error*

Existe no AutoCAD uma variável padrão que contem todas as mensagens de erros, sejam esses error causados por mau uso do programa, cancelado por parte do usuário ou um erro de programação, o que precisamos fazer é armazenar o valor dessa variável *erro* (sim essa variável se escreve com asteriscos), para fazer isso basta criar uma nova variável com o conteúdo da variável *error*.

(setq erro_antigo *error*)

Agora temos uma variável chamada erro_antigo que contem todos os dados da função de erro do AutoCAD, agora como já criamos de certa forma um backup desse *error* podemos altera-lo da maneira que quisermos, pois poderemos restaura-lo.

Função *error*

Agora precisamos criar uma nova função *error* (sim todo o conteúdo da variável *error* é uma função) e nela podemos fazer o que quisermos ate mesmo mudar as mensagens de erro.

Primeiro vamos criar um função que armazene todas as variáveis de sistema que vamos modificar e logico a própria função *error*.

(defun guarda_variaveis ()
  (setq cmdecho (getvar "cmdecho"))
  (setq orthomode (getvar "Orthomode"))
  (setq osmode (getvar "osmode"))
  (setq clayer (getvar "clayer"))
  (setq cecolor (getvar "cecolor"))
  (setq filedia (getvar "filedia"))
  (setq attreq (getvar "attreq"))
  (setq attdia (getvar "attdia"))
  (setq erro_antigo *error*)
  )

Note que armazenamos na variável erro_antigo a função *error*

Agora uma função que restaure as variáveis.

(defun restaura_variaveis()
  (setvar "cmdecho" cmdecho)
  (setvar "Orthomode" Orthomode)
  (setvar "osmode" osmode)
  (setvar "clayer" clayer)
  (setvar "cecolor" cecolor)
  (setvar "filedia" filedia)
  (setvar "attreq" attreq)
  (setvar "attdia" attdia)
  )

Agora criamos a nossa função de erro, vamos chama-la de meu_erro.

(defun meu_erro (MSG)
(setq *error* erro_antigo)
(restaura_variaveis)
(prompt "\nComando cancelado!")
)

Note que restauramos a função  *error* que estava armazenada na variável erro_antigo.

Para finalizar precisamos dizer ao Autolisp que essa agora é a nova função  *error*.

(setq *error* Meu_erro)

Vamos ver como ficaria um programa com a chamada para esse novo erro.

(defun c:tt()
  (guarda_variaveis)
  (setq *error* meu_erro)
  (setq nome (getstring "\nDigite o seu primeiro nome: "))
  (setq pt1 (getpoint "\nClique sobre o local desejad: "))
  (command "text" pt1 "2" "0" nome)
  (restaura_variaveis)
  )

Pronto, agora toda vez que um erro acontecer à função meu_erro será chamada, quando isso acontecer ele vai restaurar as variáveis de sistema e alterar a função *error* para a sua função original.

É importantíssimo voltar a função *erro* para o original caso contrario todas as mensagens de erro do AutoCAD serão igual à função meu_erro, caso você esqueça esse procedimento, fique tranquilo pois quando o desenho for fechado e aberto a função *error* padrão será carregada automaticamente pelo AutoCAD.

Assistam a vídeo aula pois nela será explicado passo a passo como isso se comporta dentro de um programa.

Abaixo segue o link do meu canal Manual de Cad no youtube.

https://www.youtube.com/watch?v=WLJZN_k6wag&feature=youtu.be

Espero que tenham gostado

Sérgio Fernandes.

Manual de Cad.

 

 

Aula 24–Exercícios Funções

 

Olá pessoal, nessa aula teremos apenas a veio aula no nosso canal Manual de Cad no youtube. Abaixo segue o link.

https://www.youtube.com/watch?v=ePSQkPkrI18&feature=youtu.be

Espero que tenham gostado

Sérgio Fernandes

Manual de Cad.

Aula 23 – Criando Funções – Parte 2

 

Olá pessoal, vamos dar continuidade a nossa aula de funções, aprendemos como definir uma função com ou sem argumento, retornando ou não um valor, hoje aprenderemos como inicializar uma variável e quando e porque devemos inicializa-las.

Quando queremos criar uma função com argumentos basta digita-los dentro dos parênteses, porem quando vamos definir as variáveis que queremos inicializar devemos antes colocar uma barra dividindo o argumento das variáveis, o que estiver do lado esquerdo da barra são os argumento o que estiver do lado direito são as variáveis.

Sintaxe:

(defun <nome da função> ([argumentos] / [Variáveis a inicializar])

Quando não possuímos as variáveis a inicializar não necessitamos fazer uso da barra, porem quando ocorre o contrario quando não possuímos argumentos mas apenas as variáveis que queremos inicializar precisamos colocar a barra.

Exemplos:

1) Somente com argumentos .

     (defun calcula_hipotenusa (oposto adjacente)

2) Com argumento e variáveis a inicializar .

     (defun  calcula_hipotenusa (oposto adjacente / hip)

3) Somente com variáveis a inicializar.

     (defun calcula_hipotenusa (/ hip)

Toda vez que inicializamos uma variável temos uma certeza absoluta, a variável vai estar sem valor quando o programa for iniciado.

Sim pessoal é exatamente isso, uma variável quando inicializada mesmo que ela possua valor esse valor será perdido e ela será definida como nil quando a função for acionada.

Mas porque isso? fiquem tranquilos no momento são poucos os exemplos que posso dar a vocês com o conteúdo que aprendemos até agora, no decorrer do curso usaremos muito o recurso de  inicializar uma variável.

Quando  e como saber quais variáveis inicializar ou não, isso depende de diversos fatores, para que serve a função, qual a serventia dessa variável dentro da função e como foi desenvolvida a função.

Um erro muito comum é inicializar todas as variáveis de uma função, isso além de desnecessário pode dificultar a depuração do programa.

Vou pedir paciência a todos vocês, voltaremos a falar desse assunto novamente em breve e com os exemplos corretos vocês poderão entender melhor esse assunto. Na nossa vídeo aula veremos mais facilmente o comportamento dessas variáveis.

Abaixo segue o link dessa vídeo aula no meu canal Manual de Cad no youtube.

https://www.youtube.com/watch?v=PAyYjFpI6fY&feature=youtu.be

Espero que tenham gostado

Sergio Fernandes

Manual de Cad.

Aula 22 – Criando Funções – Parte 1

 

Chegamos hoje ao tópico mais importante do nosso curso, desde que iniciamos o nosso curso todos os nossos programas começam e terminam em uma única chamada, porem quando programamos essa é uma pratica ruim, o correto é subdividir o programa em pequenas funções, isso facilita a depuração e torna o programa mais fácil de entender.

Existem dois tipos de funções as que retornam valores e as que não retornam, dependendo da situação podemos utilizar uma ou a outra.

Função DEFUN

Já usamos muito essa função porem não sabemos nada dela ainda, o que sabemos ate agora é que para criar um comando devemos digitar (defun c: SS(), tudo bem decorado e a  unica coisa que sabemos é que devemos colocar C: sempre que for um comando, agora aprenderemos mais sobre ela e como usa-la corretamente.

Defun significa definir função, e quando queremos criar uma função devemos seguir a sintaxe abaixo:

Sintaxe:

(defun <nome da função> ([argumentos] / [Variáveis a inicializar])

Nossa complicou, cadê o C:, o que é argumentos, porque eu preciso inicializar as variáveis e o que é essa barra invertida no meio dos dois, calma, vamos por partes e logo vocês vão entender tudinho.

1) Quando criamos uma função não podemos usar o C:, só o utilizamos quando queremos criar um comando para ser usado na linha de comando do AutoCAD.

2) O nome da função não pode conter espaços se necessário utilize o Underline _.

3) Argumento e inicialização de variáveis é opcional em uma função.

O que sobrou agora é falar dos argumentos e das variáveis a inicializar, porem vamos deixar de lado por enquanto a variáveis a iniciar, logo falaremos delas, para que vocês entendem o que é uma função e para que ela serve vamos fazer dois exemplos um matemático e outro usando comandos do AutoCAD e Autolisp. O exemplo matemático vai ser uma função que retorna um valor e a outra que usaremos comandos do AutoCAD será uma função que não retorna valor, isso não é regra nem qualquer coisa do tipo, isso fui eu que defini, podemos ter funções matemáticas que não retornam valor ou vice versa.

Exemplo 1:

Vamos criar uma função que retorne a valor da hipotenusa, para fazer isso precisaremos de dois argumentos, uma para o cateto oposto e outro para o cateto adjacente, vamos chama-los de oposto e adjacente e a nossa função chamaremos de hipotenusa.

(defun hipotenusa ( aposto adjacente )

Olhe a linha de programação acima o que estamos falando é que toda a vez que eu usar essa função chamada hipotenusa vou fornecer dois argumentos o primeiro será o valor destinado ao cateto oposto e o segundo ao adjacente, os dados deverão ser fornecidos nessa ordem.

(setq hip (sqrt (+ (exp oposto 2) (exp adjacente 2))))

Nessa linha apenas calculamos a hipotenusa usando as funções matemáticas.

Agora precisamos fazer com que a nossa função retorne o valor da hipotenusa, para fazer uma função retornar um valor basta colocar o nome da variável ao fim do programa sem os parênteses, conforme mostrado abaixo:

(defun hipotenusa(oposto adjacente)
  (setq hip (sqrt (+ (expt oposto 2) (expt adjacente 2))))
  hip
  )

Criamos a nossa primeira função e ela é uma função que retorna um valor, agora precisamos saber como usa-la, para usar uma função basta digita-la cercada por parênteses com os valores dos argumentos que deseja usar, como essa função retorna um valor precisamos armazenar esse valor dentro de uma variável para poder utiliza-lo futuramente.

(setq valor_hipotenusa (hipotenusa 3 4))

Vamos analisar a linha de programação acima, criamos uma variável chamada valor_hipotenusa e vamos armazenar nela o resultado da função hipotenusa, a função hipotenusa recebeu dois valores, 3 que é o cateto oposto e 4 o cateto adjacente, quando essa linha de programação estiver rodando o Autolisp chamara a função hipotenusa e vai colocar o valor 3 na variável oposto e o 4 na variável adjacente e executar o calculo dentro da função e o valor do calculo é armazenado na variável Hip  e retornado ao fim, esse valor retornado é o valor que ficara armazenado na variável valor _hipotenusa (isso será compreendido melhor na vídeo Aula com a ajuda o Visual Lisp).

Agora temos uma função que a qualquer momento podemos chama-la e usa-la dentro dos nosso programas, uma função pode ser usada por diversos programas basta estar carregada no momento for ser utilizada.

Uma função não precisa obrigatoriamente retornar um valor ou ter obrigatoriamente argumento, veja o exemplo abaixo:

Exemplo 2:

Vamos criar uma função que armazene as variáveis de sistema e outra função para restaura-las, essa função não terá argumento nem retornara valores.

(defun armazenar_var_sistema()
  (setq osm (getvar "osmode"))
  (setq ortho (getvar "orthomode"))
  (setq layer (getvar "clayer"))
  (setq cmd (getvar "cmdecho"))
  )

(defun restaurar_var_sistema()
  (Setvar "osmode" osm)
  (Setvar "orthomode" ortho)
  (Setvar "clayer" layer)
  (Setvar "cmdecho" cmd)
  )

Criamos duas funções note que nenhuma das duas tem argumento e nenhuma delas retorna qualquer valor, elas apenas executam algumas funções em Autolisp, no nosso caso elas armazenam e restauram as variáveis de sistema.

Para chama-las basta escrever o nome da função cercada por parênteses. Veja o programa baixo:

(defun c:pp()
  (armazenar_var_sistema)
  (Setvar "cmdecho" 0)
  (Setvar "osmode" 0)
  (setq pt1 (Getpoint "\nClique sobre o primeiro ponto: "))
  (setq pt2 (Getpoint pt1 "\nClique sobre o segundo ponto: "))
  (Setvar "orthomode" 1)
  (prompt "\nEsse novo ponto devera ser feito de forma ortogonal.")
  (setq pt3 (Getpoint pt2 "\nClique sobre o segundo ponto: "))
  (command "layer" "n" "linha" "c" "5" "linha" "")
  (Setvar "clayer" "linha")
  (command "line" pt1 pt2 pt3 "")
  (restaurar_var_sistema)
  (princ)
  )

Logo no inicio do programa fazemos o armazenamento das variáveis e depois vamos alterando o valor delas conforme a nossa necessidade e no final restauramos elas para o que seu estado antes de rodar o programa. Essas duas funções podem ser usadas em qualquer programa a qualquer momento quantas vezes vocês quiserem.

Pessoal ainda tem mais, mas vai ficar para a segunda parte dessa aula.

Abaixo segue o link dessa vídeo aula no meu Canal manual de Cad no youtube.

https://www.youtube.com/watch?v=o0GDNvfwiK4&feature=youtu.be

Espero que tenham gostado.

Sergio Fernandes

Manual de Cad

 

 

 

Aula 21 – Exibição de Mensagens

 

Olá pessoal, essa aula seria sobre tratamento de erros, porém percebi que não seria legal dar essa aula sem antes ensinar como enviar mensagens para o usuário em Autolisp, essa aula é muito simples porem de extrema necessidade.

Função PROMPT

Essa função envia uma mensagem em formato texto (string) na linha de comando.

Sintaxe:

(Prompt <mensagem para o usuário>)

Exemplo:

(Defun c: pp()

  (setq pt1 (getpoint “\nClique sobre o primeiro ponto: “))

  (setq pt2 (getpoint “\nClique sobre o segundo ponto: “))

  (command “line” pt1 pt2 “”)

  (Prompt “\nA linha foi desenhada com sucesso!”)

)

Função PRINC, PRIN1 e PRINT

Essas funções costumam ser ensinadas em cursos de Autolisp junto com as funções de mensagens porém isso será feito de forma diferente nesse curso, voltaremos a falar delas novamente na aula  de tratamento de arquivos de dados.

Agora basta saber que sempre que desejarmos encerrar um comando e não queremos ter aquele nil chato que aparece no fim basta usar o (princ) no final de nossos comandos.

Exemplo:

(Defun c: pp()

  (setq pt1 (getpoint “\nClique sobre o primeiro ponto: “))

  (setq pt2 (getpoint “\nClique sobre o segundo ponto: “))

(Command “line” pt1 pt2 “”)

  (Princ)

)

Função ALERT

Exibe uma mensagem na tela forçando o usuário a ler pois para continuar a execução do programa o usuário será obrigado a pressionar o botão de OK.

Sintaxe:

(Alert <mensagem para o usuário>)

Exemplo:

(Defun c:ag()

(setvar “osmode” 4)

(Alert “Atenção clique no ponto central do arco.”)

(setq pt1 (getpoint “\nClique no centro do arco: “))

)

Atenção, devemos usar a função Alert quando for necessário enfatizar algo não devemos usa-la em demasia no programa.

Essa aula foi bem simples, porém necessária para continuarmos o nosso curso.

Abaixo segue o link dessa vídeo aula no meu canal Manual de Cad no Youtube.

https://www.youtube.com/watch?v=Oxn4MiRg_-U&feature=youtu.be

Espero que tenham gostado.

Sergio Fernandes

Aula 20 – Variáveis de Sistema

 

Olá pessoal nessa aula aprenderemos o que são variáveis de sistema e como consultar e alterar os seus valores, absolutamente tudo no Autocad é controlado por uma variável de sistema.

Para alterar ou consultar o valor de uma variável de sistema (isso é um comando do Autocad e deve ser digitado na linha de comando) usamos o comando SETVAR.

Digite na linha de comando Setvar em seguida o nome da variável que deseja consultar ou alterar em seguida entre com o novo valor.

Nem todas as variáveis de sistema do Autocad podem ser alteradas, algumas apenas podem ser consultadas, as variáveis de sistema que tiverem na sua frente escrito (read only) são as variáveis que só podem ser consultadas (somente leitura).

Porem o comando Setvar é uma comando do Autocad que pode ser digitado na linha de comando, porem em Autolisp alterar o valor de uma variável também usamos o comando Setvar.

SETVAR

Altera o valor de uma variável de sistema (apenas se a variável não for uma variável de apenas leitura).

Precisamos sempre informar o valor da variável quando usamos a função Setvar da forma que ela necessita se for 0 ou 1 precisamos entrar como numero inteiro se for uma string devemos informara-la cercada por aspas duplas.

Sintaxe:

(Setvar <nome da variável> <valor da variável>)

Exemplo:

(Setvar “orthomode” 0)

(Setvar “clayer” “teste”)

Abaixo segue uma lista com as principais variáveis de sistema (são apenas algumas):

Attdia = controla se aparecerá caixa de dialogo para inserção dos atributos de um bloco.

Cmdecho = variável que controla se aparecerá ou não o eco dos comandos do Autocad usando dentro de um programa.

Orthomode = ativa ou desativa a função ortogonal mode (tecla F8).

Dwganame = retorna o nome do desenho (apenas leitura).

Dwgprefix = retorna o caminho completo onde esta salvo o desenho (apenas Leitura).

Osmode = controla os comandos de precisão do Autocad (na vídeo aula tem uma explicação melhor sobre essa variável de sistema).

Area = retorna a ultima area medida pelo comando area do Autocad.

Cdate = retorna a data com dia mes e ano e a horas com hora minuto e segundos.

Clayer = controla o layer corrente (o layer precisa existir para ser definido como corrente).

Filedia = controla se ao usar o comando open ou save se aparecerá janela de dialogo ou se o usuário deverá entrar com o caminho completo via linha de comando.

Insbase = mostra onde se encontra o ponto base do desenho.

Lastpoint = armazena o ultimo ponto clicado por qualquer comando do Autocad.

 

GETVAR

Retorna o valor da variável consultada, o valor pode ser armazenado em uma variável.

Sintaxe:

(Getvar <nome da variável>)

Exemplos:

(setq nome (Getvar “dwgname”))

(setq layer (Getvar “clayer”))

(setq os (Getvar “osmode”))

Quando fazemos um programa temos a liberdade para alterar as variáveis de sistema da maneira que quisermos, porem esse é um poder muito perigoso e pode ser a diferença entre um programa ajudar ou atrapalhar o usuário. O correto é armazenar todas as variáveis que vamos alterar, dessa forma ao final do programa podemos restaura-las para a sua condição inicial.

Isso é de extrema importância, por exemplo, se alterarmos o layer corrente do desenho e não restaura-lo no final o usuário pode não perceber e começar a desenhar tudo no layer errado.

Abaixo segue o link dessa vídeo aula no meu canal Manual de Cad no youtube.

https://www.youtube.com/watch?v=YMRNCivs_cA&feature=youtu.be

Espero que tenham gostado

Sergio Fernandes

Manual de Cad.