Abaixo segue o link da vídeo aula contendo o segundo exercício sobre o assunto de tomanda de decisão.
https://www.youtube.com/watch?v=hRBxoIO_sIg
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad.
Blog destinado a todos que querem aprender mais sobre esse mundo quase infinito das platormas CAD.
Abaixo segue o link da vídeo aula contendo o segundo exercício sobre o assunto de tomanda de decisão.
https://www.youtube.com/watch?v=hRBxoIO_sIg
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad.
Abaixo segue o link da vídeo aula contendo o primeiro exercício sobre o assunto de tomanda de decisão.
https://www.youtube.com/watch?v=iRf6YLLTOGo
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad.
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.
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.
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.
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
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
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.
Abaixo segue o link de mais uma aula de exercícios comentados.
https://www.youtube.com/watch?v=lovi_89xDAs&feature=youtu.be
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad.
Abaixo segue o link da aula 18 com mais uma exercício comentado.
https://www.youtube.com/watch?v=xpxXiAllDa0&feature=youtu.be
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad.
Abaixo segue o link da aula 17, faremos entre três e quatro aulas de exercícios para treinar tudo aquilo que aprendemos até agora.
https://www.youtube.com/watch?v=KGEh2et5RIE&feature=youtu.be
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad.
Hoje teremos a nossa ultima aula sobre o assunto entrada de dados e também vamos aprender mais algumas funções que não são entrada de dados mas que são de extrema importância nesse momento do curso. As próximas duas aulas serão aulas praticas onde vou explicar todos os comandos de entrada de dados.
INITGET
A função Initget faz o controle da entrada dos dados. Essa função traz mais controle ao nosso programa pois pode permite por exemplo que Getint ou Getreal somente recebam valores maiores que zero, ou ainda que o usuário obrigatoriamente forneça um ponto quando utilizamos o Getpoint.
A função Initget deve ser usada sempre antes da função desejada.
Sintaxe:
(Initget <bite>)
Abaixo segue a tabela dos bites.
1 Impede que o usuário responder à solicitação , pressionando apenas ENTER.
2 Impede que o usuário responder à solicitação , digitando zero.
4 Impede que o usuário responder à solicitação , digitando um valor negativo.
Exemplo 1:
Vamos fazer um comando simples que desenhe uma linha, se por algum motivo o usuário não clicar na tela seja no primeiro ponto ou no segundo no momento de se fazer a linha acontecerá um erro, para impedir que isso aconteça vamos usar o Initget com o Bite 1.
(defun c:l2()
(Initget 1)
(setq pt1 (Getpoint "\nClique sobre o primeiro ponto: "))
(Initget 1)
(setq pt2 (Getpoint pt1 "\nClique sobre o próximo ponto: "))
(command "line" pt1 pt2 "")
)
1) Criamos o comando L2
2) Entramos com a função Initget com o bite 1 que quer dizer que a próxima função de entrada de dados não poderá ser pulada caso o Enter seja pressionado, somente poderá sair da função se um ponto for fornecido.
3) Pede ao usuário para clicar em um ponto, devido à função Initget o usuário não conseguira sair desse comando sem clicar em um ponto da tela. Esse ponto será armazenado na variável PT1.
4) Entramos com a função Initget com o bite 1 que quer dizer que a próxima função de entrada de dados não poderá ser pulada caso o Enter seja pressionado, somente poderá sair da função se um ponto for fornecido.
5) Pede ao usuário para clicar em um ponto, devido à função Initget o usuário não conseguira sair desse comando sem clicar em um ponto da tela. Esse ponto será armazenado na variável PT2. Esse comando tem como ponto de laço a variável PT1.
6) Graças ao Initget teremos obrigatoriamente dois ponto para criar a nossa linha usando a função command.
Exemplo 2:
Vamos criar um comando que não aceite números negativos e que só aceite valores maiores do que zero também vamos bloquear para impedir que o usuário apenas pressione o Enter sem entrar com o valor, para fazer isso vamos ter que fazer uso de todos os bites que forem mostrados acima, para fazer isso basta soma-los, como vamos usar os bites 1, 2 e 4 basta soma-los e teremos o valor 7.
(defun c:imc()
(Initget 7)
(setq altura (Getreal "\nDigite a altura do usuário em metros: "))
(Initget 7)
(setq peso (Getreal "\nDigite o peso do usuário: "))
(setq imc (/ peso (expt altura 2)))
)
No exemplo acima forçamos o usuário a digitar um valor válido para ambas as variáveis altura e peso, mesmo que o usuário pressione Enter ou digite um valor negativo ou tente digitar zero o Initget não permitirá, forçando o usuário a entrar com um valor válido.
A função Initget ainda é usada com outra função de entrada de dados chamada getkword que não aprenderemos agora pois essa é uma função que não faz muito sentido explicar o seu funcionamento sem antes aprendermos a usar as funções condicionais.
Funções Geométricas
Pessoal vou inserir essa aula junto com as funções de entrada de dados porque fica muito mais fácil explicar os dois assuntos juntos, nas próximas aulas farei varios vídeos explicando como usa-las em conjuntos.
DISTANCE
Retorna a distancia entre dois pontos.
Sintaxe:
(Distance <ponto 1> <ponto 2>)
Exemplo:
(defun c:dd()
(setq pt1 (Getpoint "\nClique sobre o primeiro ponto: "))
(setq pt2 (Getpoint pt1 "\nClique sobre o segundo ponto: "))
(setq distancia (Distance pt1 pt2))
)
1) Criamos o comando DD.
2) Solicitamos um ponto ao usuário com a função Getpoint e armazenamos esse ponto na variável PT1.
3) Solicitamos outro ponto ao usuário com a função Getpoint e armazenamos esse ponto na variável PT2.
4) Usando a função Distance obtemos a distancia entre PT1 e PT2.
Quando ensinei o comando Getdist informei que não gostava de usa-lo pois ele retornava apenas a distancia sem guardar o ponto clicado, com a função Distance podemos armazenar os pontos com getpoint e depois extrair a distancia.
ANGLE
Retorna o angulo em radianos a partir de pois pontos.
Sintaxe:
(Angle <ponto 1> <ponto 2>)
Exemplo:
(defun c:ang()
(setq pt1 (Getpoint "\nClique sobre o primeiro ponto: "))
(setq pt2 (Getpoint pt1 "\nClique sobre o segundo ponto: "))
(setq angulo (Distance pt1 pt2))
)
1) Criamos o comando ang.
2) Solicitamos um ponto ao usuário com a função Getpoint e armazenamos esse ponto na variável PT1.
3) Solicitamos outro ponto ao usuário com a função Getpoint e armazenamos esse ponto na variável PT2.
4) Usando a função Angle obtemos o angulo em radianos entre PT1 e PT2.
Muitos devem estar pensando pra que serve esse angulo em radianos, fiquem calmos teremos uma aula voltada somente para a conversão de dados.
POLAR
Retorna um ponto no espaço. Porem para fazer isso ele requer um ponto de partida o angulo e a distancia a ser percorrida, o resultado será uma lista contendo as coordenadas X,Y e Z.
Sintaxe:
(polar <ponto de partida> <angulo em radianos> <distancia>)
Exemplo:
Vamos criar uma função que faça um circulo no centro de uma linha, vamos clicar em dois pontos para fazer a linha e em seguida o programa vai achar automaticamente o meio da linha e fara um circulo.
(defun c:ptm()
(setq pt1 (Getpoint "\nClique sobre o primeiro ponto: "))
(setq pt2 (Getpoint pt1 "\nClique sobre o segundo ponto: "))
(setq angulo (Angle pt1 pt2))
(setq distancia (/ (Distance pt1 pt2) 2))
(setq ptc (polar pt1 angulo distancia))
(command "line" pt1 pt2 "")
(command "circle" ptc 10)
)
1) Criamos o comando PTM.
2) Solicitamos um ponto e armazenamos em PT1.
3) Solicitamos o segundo ponto e armazenamos seu valor em PT2.
4) Utilizando a função Angle pegamos o angulo de PT1 a PT2 (note que é diferente pegar o angulo de PT1 a PT2 ou de PT2 a PT1, a ordem dos fatores aqui pode alterar o produto, como meu ponto de partida no comando polar será PT1 eu então peguei o angulo de PT1 a PT2)
5) Utilizando a função Distance armazenamos a distancia de PT1 a PT2 na variável distancia, porem como não precisamos saber a distancia total e sim somente da metade pois a nossa intenção é pegar o ponto do meio da linha dividimos o valor da distancia por 2.
6) Usando a função polar indicamos o ponto de partida como sendo PT1 e fornecemos o angulo e a distancia (mesmo nome das variáveis), o resultado será uma lista contendo as coordenadas desse novo ponto.
7) Usando a função command criamos uma linha de PT1 a PT2.
8) Usando a função command criamos um circulo de raio de 10 com o ponto central em PTC que é o ponto do meio da linha.
Pessoal, na próxima aula teremos muitos exemplos, muitos programas comentados, quem não entendeu alguma coisa aguarde as próximas aulas.
Abaixo segue o link dessa vídeo aula no meu canal Manual de Cad no Youtube.
https://www.youtube.com/watch?v=GOPStIdiR6k&feature=youtu.be
Espero que tenham gostado.
Sérgio Fernandes
Manual de Cad.
Olá pessoal, vamos dar continuidade ao nosso curso falando ainda sobre as funções de entrada de dados.
GETSTRING
A função Getstring retorna um texto digitado pelo usuário, o retorno dessa função independente do que for digitado será sempre uma string.
Sintaxe:
(Getstring [T] [mensagem para o usuário])
T= Com esse argumento na função Getstring a mesma passa a aceitar espaços em branco, caso contrário ao pressionar a barra de espaço ele entenderá como um Enter.
Exemplo 1:
(defun c:tx()
(setq nome (Getstring "\nDigite o primeiro nome: "))
(setq pt1 (Getpoint "\nClique sobre o local desejado: "))
(command "text" pt1 "2" 0 nome)
)
1) Criamos um comando TX
2) Usando a função Getstring solicitamos ao usuário que digite o seu primeiro nome, nesse caso como foi suprimido o argumento T não será aceito espaços em branco, quando o usuário pressionar a barra de espaço o comando entendera que o Enter foi pressionado. O texto digitado será armazenado na variável NOME.
3) Usando o Getpoint solicitamos que o usuário clique em qualquer ponto da tela, esse ponto será armazenado na variável PT1.
4) Usando a função command vamos criar um texto no ponto PT1 com altura 2 e rotação zero e o texto será o texto que foi armazenado na variável NOME.
Exemplo 2:
(defun c:tx()
(setq nome (Getstring t "\nDigite o nome e sobrenome do usuário: "))
(setq pt1 (Getpoint "\nClique sobre o local desejado: "))
(command "text" pt1 "2" 0 nome)
)
1) Criamos um comando TX
2) Usando a função Getstring solicitamos ao usuário que digite o primeiro nome, nesse caso como foi utilizado o argumento T que faz com que a função Getstring aceite espaços em branco. O texto digitado será armazenado na variável NOME.
3) Usando o Getpoint solicitamos que o usuário clique em qualquer ponto da tela, esse ponto será armazenado na variável PT1.
4) Usando a função command vamos criar um texto no ponto PT1 com altura 2 e rotação zero e o texto será o texto que foi armazenado na variável NOME.
GETINT e GETREAL
A função Getint retorna um número inteiro. Caso o dado fornecido não seja um número inteiro ele vai dar uma mensagem de erro e solicitara automaticamente um novo dado.
A função Getreal retorna sempre um número decimal mesmo que o número inserido seja um número inteiro, essa função aceita qualquer tipo de número, inteiro, decimal, negativo etc. Caso o dado informado não seja um número uma mensagem de erro será exibida e o programa solicitará um novo número.
Sintaxe GETINT:
(Getint [mensagem para o usuário])
Sintaxe GETREAL:
(Getreal [mensagem para o usuário])
Exemplo:
(defun c:imc()
(setq idade (Getint "\nDigite a idade do usuário: "))
(setq altura (Getreal "\nDigite a altura do usuário em metros: "))
(setq peso (Getreal "\nDigite o peso do usuário: "))
(setq imc (/ peso (expt altura 2)))
)
1) Criamos o comando IMC
2) Usando Getint solicitamos ao usuário que digite a idade do usuário, como geralmente a idade é sempre fornecida como um número inteiro utilizar o Getint garante que receberemos o dado da maneira que imaginamos. Esse valor é armazenado na variável idade.
3) Utilizando Getreal solicitamos ao usuário que digite a sua altura, como geralmente a altura é um valor decimal utilizamos o Getreal. Esse valor será armazenado na variável altura.
4) Utilizando Getreal solicitamos ao usuário que digite o seu peso, como geralmente o peso é um valor decimal utilizamos o Getreal. Esse valor será armazenado na variável peso.
5) Usando o peso e a altura fazemos o calculo o IMC que é o peso dividido pela altura ao quadrado.
Na próxima aula continuaremos falando mais um pouco sobre as funções de entrada de dados.
Baixo segue o link dessa aula no meu canal Manual de Cad no Youtube.
https://www.youtube.com/watch?v=CFcMAl3kyUg&feature=youtu.be
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad.
Olá pessoal vamos continuar falando sobre as funções de entrada de dados, agora que aprendemos a usar a função Getpoint tudo fica mais fácil pois quase todas as funções get se comportam da mesma maneira.
GETCORNER
A função Getcorner retorna assim como o Getpoint uma lista contendo as coordenadas X Y e Z do ponto selecionado, porem diferente do Getpoint que não necessita do ponto de laço que fornecerá uma linha auxiliar o Getcorner precisa desse ponto de laço pois a partir dele será mostrada uma janela de box auxiliar.
.
Sintaxe:
(Getcorner <ponto de laço> [mensagem para o usuário])
Exemplo1:
(defun c:zw()
(setq pt1 (Getpoint "\nClique sobre o local desejado: "))
(setq pt2 (Getcorner pt1 "\nAbra uma janela: "))
(command "zoom" pt1 pt2)
)
1) Definimos o nome do nosso comando ZW.
2) Usando o Getpoint armazenamos na variável PT1 uma lista contendo as coordenadas.
3) Agora armazenamos uma lista contendo X Y Z na variável PT2 usando o Getcorner, o Getcorner terá como ponto de laço a variável PT1.
4) Usamos o comando zoom para aproximar a visualização na janela indicada.
GETDIST
Getdist diferentemente do Getpoint e Getcorner que retornam uma lista o Getdist retorna uma distancia (valor numérico decimal) entre dois pontos, essa função também requer o ponto de laço que é o ponto de partida para medir a distancia porem ele também é opcional, caso você não defina o ponto de laço o programa vai pedir que primeiro clique sobre o ponto de laço para depois pedir o segundo ponto e retornar a distancia.
Sintaxe:
(Getdist [ponto de laço] [mensagem para o usuário])
Exemplo:
(defun c:med()
(setq pt1 (Getpoint "\nClique sobre o ponto inicial: "))
(setq distancia (Getpoint pt1 "\nClique sobre o ponto final: "))
)
1) Criamos a função MED.
2) Armazenamos na variável PT1 os pontos para serem usado como ponto de laço.
3) Indicamos o ponto final, o valor armazenado na variável distancia será a distancia entre o ponto de laço e o ponto indicado pelo usuário.
Mais a frente no curso veremos que essa função mesmo parecendo ser útil não tem tanta utilidade assim, aprenderemos a pegar a distancia sem usa-la e veremos teremos mais recursos na mão se não a utilizarmos.
GETANGLE E GETORIENT
Retornam o angulo em radianos, essas duas funções são bem parecidas porem podem nos fornecer resultados diferentes.
Getangle retorna o angulo a partir do angulo 0 graus definido pelo usuário e que pode ser configurado pela variável de sistema ANGBASE.
Getorient retorna o angulo levando em conta que o angulo 0 graus que se encontra sempre ao leste (lado direito).
Quando for usar essas duas funções precisa escolher da maneira correta, precisa verificar se usara o angulo maquina ou o angulo definido pelo usuário, isso é muito importante e pode fazer você ficar doido tentando encontrar onde esta dando errado.
Sintaxes:
(Getangle [ponto de laço] [mensagem para o usuário])
(Getorient [ponto de laço] [mensagem para o usuário])
Exemplo (Getorient)
(defun c:ang()
(setq pt1 (Getpoint "\nClique sobre o ponto desejado: "))
(setq angulo (Getorient pt1 "\nIndique o angulo desejado: "))
)
1) Definimos o nome do nosso comando ANG.
2) Usando o Getpoint armazenamos na variável PT1 que será nosso ponto de laço.
3) Usando o ponto PT1 como ponto de laço devemos indicar com o mouse o angulo desejado o seu resultado será armazenada na variável angulo em radianos.
No exemplo abaixo indicamos o angulo de 90º graus e recebemos como retorno o valor 1.5708 que é o radiano de 90º.
Não importa qual angulo foi configurado como sendo o angulo 0 na variável de sistema ANGBASE o Getorient sempre usara o zero grau oficial (Leste, lado direito).
Exemplo (Getangle)
(defun c:ang()
(setq pt1 (Getpoint "\nClique sobre o ponto desejado: "))
(setq angulo (Getangle pt1 "\nIndique o angulo desejado: "))
)
1) Definimos o nome do nosso comando ANG.
2)) Usando o Getpoint armazenamos na variável PT1 que será nosso ponto de laço.
3) Usando o ponto PT1 como ponto de laço devemos indicar com o mouse o angulo desejado o seu resultado será armazenada na variável angulo em radianos.
No exemplo definiremos a variável ANGBASE para 90º, isso que dizer que o Getangle entendera que toda vez que entrarmos com o angulo de 90º ele deverá entender como angulo 0º
Nesse caso tivemos como retorno 0 radianos que equivale ao angulo 0º mesmo tendo fornecido o angulo de 90º, isso porque ele levou em conta o angulo base que é controlado pela variável de sistema ANGBASE.
Se a variável de sistema ANGBASE estiver configurada como 0º Getangle e Getorient forneceram o mesmo resultados.
Abaixo segue o link dessa aula no meu canal manual de Cad no youtube.
https://www.youtube.com/watch?v=zw6nZyaPNhI&feature=youtu.be
Espero que tenham gostado.
Sergio Fernandes
Manual de Cad