Manual de Cad: Autolisp

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.

Aula 15 – Funções de Entrada de Dados – Parte 3

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.

quinta-feira, 12 de março de 2015

Aula 14 – Funções de Entrada de Dados – Parte 2

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

segunda-feira, 9 de março de 2015

Aula 13 – Funções de Entrada de Dados – Parte 1

Olá pessoal, nessa aula vamos aprender como fornecer ao Autolisp dados fornecidos pelo usuário e como manipular esses dados dentro do programa, essa aula é muito simples principalmente se você já absorveu o conteúdo das aulas anteriores.

As funções que vamos aprender hoje são as funções GET, para não ter uma quantidade muito grande de funções para dar exemplos, vamos dividir essa aula em três partes assim teremos tempo para ver vários exemplos diferentes.

GETPOINT

O Getpoint retornará uma lista contendo os pontos X Y e Z do ponto que foi indicado pelo usuário

Sintaxe:

(Getpoint [ponto de laço] [mensagem para o usuário])

Ponto de laço = deve ser uma lista contendo as coordenadas X Y e Z

Mensagem para o usuário = deverá ser uma string

Todos os argumentos para a função Getpoint são opcionais (lembre-se em uma sintaxe qualquer argumento cercado por colchetes é opcional) podendo simplesmente usar a função assim (Getpoint) que ela funcionará, veja o exemplo abaixo sem usar nenhum argumento para a função Getpoint.

(setq pt (Getpoint))

A linha de programação acima solicitara que o usuário clique em um ponto na tela, o resultado dessa interação será ima lista contendo X Y e Z.

X = 369922.0

Y = 309640.0

Z = 0.0

Podemos fazer uso dos argumentos também e deixar o programa mais amigável, uma forma de fazer isso é dando uma mensagem que vai auxiliar o usuário a entender o que deve ser feito, veja a linha de programação abaixo:

(setq pt (Getpoint “\nClique sobre o local desejado”))

ATENÇÃO: Na mensagem acima temos um delimitador \n (barra n) isso informa ao Autolisp que ele deverá pular uma linha e depois imprimir a mensagem na linha de comando, faremos sempre uso desse delimitador em nossos programas.

A linha de programação acima funcionará igual ao exemplo anterior com a diferença que o usuário receberá na linha de comando uma mensagem que vai auxilia-lo.

Veja que ele escreveu na linha de comando a mensagem e na frente ele retornou a lista contendo as coordenadas X Y e Z essa lista foi armazenada na variável PT e poderemos usar essa variável a qualquer momento em nosso programa.

Podemos também fazer uso do argumento ponto de laço esse ponto de laço mostrara uma linha auxiliar a partir do ponto de laço fornecido, veja o exemplo abaixo:

(defun c: se()

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

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

)

Esse comando acima chamado SE solicita na primeira linha que o usuário clique em qualquer ponto da tela, esse ponto será armazenado na variável PT1, depois ele pede um segundo ponto porem foi fornecido como ponto de laço a variável PT1, quando o usuário for clicar no segundo ponto uma linha auxiliar aparecerá tendo como ponto base o ponto fornececido inicial e que foi armazenado em PT1.

Essa linha auxiliar é muito util quando por exemplo queremos traçar uma linha assim podemos vizualizar o resultado antes mesmo de clicar no ponto.

Agora vamos fazer um exemplo um pouco mais complicado utilizando a função Getpoint, vamos fazer um programa onde o usuário clica em um ponto e o programa desenha um quadrado de 10x10, por enquanto faremos um quarado com um valor gravado direito no programa, mas nas próximas aulas aprenderemos quando alterar esse valor durante a execução do programa.

Vamos pensar um pouco antes de sair programando. Se utilizarmos a função GETPOINT teremos apenas uma lista contendo as coordenadas de X Y e Z, porem já aprendemos a manipular uma lista sendo assim podemos ter de forma separada os valores de X Y e Z e a partir desses valores somar valores e criar novos pontos e assim criar o nosso quadrado, veja a imagem abaixo isso facilitará o entendimento do exercício.

Do PT1 ao PT2 estamos deslocando apenas em X

Do PT1 ao PT3 estamos deslocando em X e Y

Do PT1 ao PT4 estamos deslocando apenas em Y

Vamos então dar início ao programa

(defun c:qa()
(setq pt1 (Getpoint "\nClique sobre o local desejado: "))
(setq x (car pt1))
(setq y (car (cdr pt1)))
(setq pt2 (list (+ x 10) y))
(setq pt3 (list (+ x 10) (+ y 10)))
(setq pt4 (list x (+ y 10)))
(command "line" pt1 pt2 pt3 pt4 pt1 "")
)

Vamos entender o programa

1) Criamos a variável PT1 usando Getpoint e armazenamos nela uma lista contendo X Y e Z

2) Usando a função CAR pegamos o valor da coordenada X e armazenamos em uma variável também chamada X

3) Usando a função CAR e CDR pegamos o valor da coordenada Y e armazenamos em uma variável também chamada Y

4) Criamos uma variável PT2 nela armazenamos uma lista, essa lista foi criada com os seguintes dados:

(+ x 10) = que é o valor de X da variável PT1 somando 10

Y = que é o valor de Y da variável PT1

Note que do ponto pt1 ao pt2 nos movemos apenas em X portanto somamos 10 apenas a essa coordenada.

5) Criamos uma variável PT3 nela armazenamos uma lista, essa lista foi criada com os seguintes dados:

(+ x 10) = que é o valor de X da variável PT1 somando 10

(+ y 10) = que é o valor de Y da variável PT1 somando 10

Lembre-se que estamos sempre partindo do ponto PT1 e se olharmos perceberemos que nos movemos tanto em X quanto em Y para chegar a esse ponto.

5) Criamos uma variável PT4 nela armazenamos uma lista, essa lista foi criada com os seguintes dados:

x = que é o valor de X da variável PT1

(+ y 10) = que é o valor de Y da variável PT1 somando 10

Olhando sempre pelo ponto PT1 notamos que para chegar o PT4 nos movemos apenas em Y, portanto somamos mais 10 apenas em Y.

6) Criamos a linha partindo de PT1 e terminamos em PT1 para fechar o quadrado.

Quem tiver a oportunidade de assistir a vídeo aula poderá ver esse exemplo melhor explicado.

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

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

Espero que tenham gostado.

Abaixo seguem os exercicios

1) Utilizando o getpoint crie um comando que que desenhe uma escada com 3 degraus com 10 cm de altura e 15 de comprimento. o Usuário deverá clicar em apenas um ponto.

2) Tente refazer o exemplo da Aula 12 utilizando o getpoint.

Sergio Fernandes

Manual de Cad.

quinta-feira, 5 de março de 2015

Aula 12 – Criando Comandos- Parte 3

Olá pessoal esse post será somente com video aula, nessa aula mostro mais exemplos e tento explicar melhor como usar a função command.

Abaixo segue o link da video aula em nosso canal Manual de Cad no youtube:

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

Espero que tenham gostado

Sérgio Fernandes

Manual de Cad.

terça-feira, 3 de março de 2015

Aula 11 – Criando Comandos-Parte 2

Olá pessoal esse post será somente com video aula, nessa aula mostro mais exemplos e ensino alguns truques e dou algumas dicas.

Abaixo segue o link da video aula em nosso canal Manual de Cad no youtube:

https://www.youtube.com/watch?v=yc71gc9M3b4

Espero que tenham gostado

Sérgio Fernandes

Manual de Cad.

quarta-feira, 25 de fevereiro de 2015

Aula 9–Revisão do Autocad

Como essa aula seria muito difícil de ser escrita e explica aqui em formato texto no blog fiz apenas a vídeo aula. Abaixo segue o link.

https://www.youtube.com/watch?v=PfhbMDH-6Tw&feature=youtu.be

Espero que tenham gostado

Sérgio Fernandes

Manual de Cad

segunda-feira, 23 de fevereiro de 2015

Aula 10 – Criando Comandos-Parte 1

Olá pessoal, chegou a hora que todos vocês esperavam, vamos criar comandos em Autolisp, mas antes precisamos definir o que será necessário para que vocês consigam criar comandos que realmente ajudem vocês no dia a dia.

1) É necessário ter fortes conhecimentos em Autocad e seus comandos, se você aprendeu com Autocad em português ou usando ícones ou menu estará em grande desvantagem, o ideal é utilizar o Autocad usando a linha de comando e conhecer os comandos pelo seu nome inteiro e não pelo atalho.

2) Imaginação, sim para criar comandos da forma que eu vou ensinar precisa de muita imaginação.

3) Treino

4) Treino de novo.

O que vou ensinar aqui é apenas uma pequena parte do que é possível fazer em Autolisp, na verdade muito pequena mesmo, porem quando eu estava iniciando meu aprendizado em Autolisp não existia muita literatura, youtube ou blogs e isso que vou ensinar agora foi a primeira coisa que eu aprendi em Autolisp e apos muito tempo percebi que não podia ser somente isso e ai corri para aprender tudo o que precisava. O que posso dizer é que a matéria de hoje facilitou muito meu aprendizado acredito que treina-la com exaustão me tornou o ótimo programador que sou hoje e principalmente um usuário avançado do Autocad.

O que vou pedir para vocês agora é apenas decorar o que eu vou escrever, mais a frente no curso vamos conversar mais sobre esse assunto.

Criando o primeiro comando

Para criar um comando precisamos definir o nome do comando para fazer isso usamos o comando DEFUN, abaixo segue a sintaxe desse comando:

(defun c: <nome do comando> ()

Vamos falar um pouco dessa sintaxe:

DEFUN = Definir função

c: = Quer dizer que o a função será um comando usado no Autocad

() = Lista de argumentos

No momento basta decorar isso, no futuro quando começarmos a criar funções precisaremos falar um pouco mais detalhadamente sobre essa linha de programação.

Ótimo, já sabemos como começar o nosso programa, agora precisamos saber como criar o comando em si, para isso vamos sempre fazer o uso de um papel e uma caneta, principalmente se você não tem um domínio tão grande dos comandos do Autocad.

Com papel e caneta nas mãos vamos começar.

Nosso primeiro programa vai ser um programa bem simples, vamos clicar em um ponto qualquer na tela, fazer um circulo com raio de 10 e pinta-lo com a cor vermelha.

A) Precisamos saber como o comando circulo funciona passo a passo, por isso precisamos de papel e caneta para anotar todos os passos, se você abrir o Autocad e for fazer um circulo com raio de 10 certamente seguira os seguintes passos:

1) Digitar o comando circle.

2) Clicar em um ponto qualquer da tela.

3) Digitar o raio.

B) Precisamos agora saber os passos necessários para pintar o circulo de vermelho, muitos podem pensar que é só clicar nele e depois mudar a cor na barra de propriedade do Autocad, porem não é assim, precisamos de um comando em linha de comando que faça essa tarefa, temos varias formas de fazer isso, mas no momento faremos uso do comando CHPROP, se você não conhece esse comando tente aprender mais sobre ele (seu uso já foi ensinado na aula 9), pois usaremos muito durante o curso. Os passos baixo são necessários para mudar a cor de um objeto:

1) Digitar o comando chprop

2) Selecionar o objeto.

3) Pressionar ENTER para informar ao Autocad que não vamos mais selecionar nenhum objeto.

4) Digitamos a opção C (de color)

5) Digitamos o numero da cor, no Autocad a cor vermelha é o numero 1 (no final do blog colocarei uma tabela com as 9 primeiras cores do Autocad).

6) Pressionamos ENTER para informar ao comando chprop que não vamos mais mudar nenhuma propriedade do objeto e que o mesmo pode ser encerrado.

Agora que anotamos como os comandos funcionam precisamos entender mais uma coisa, quando digitamos o nome do comando no Autocad precisamos em seguida pressionar o ENTER para confirmar o comando, porem, em Autolisp esse ENTER será dado de forma Automática. O mesmo ocorre quando digitamos um dado como o raio do circulo ou clicarmos na tela.

Porem quando um comando permite que selecionemos vários objetos precisamos em um determinado momento informar ao comando que não queremos mais selecionar nenhum objeto e para fazer isso pressionamos o ENTER, nesse caso precisamos anotar, pois será necessário também informar em Autolisp esse ENTER.

A mesma coisa acontece quando o comando somente é encerrado quando você pressiona ENTER para informa-lo que você não fará mais nenhuma modificação no objeto, isso acontece, por exemplo, com o comando chprop que continuara no comando ate que você pressione ENTER ou pressione o ESC (cancelando o comando), no caso do comando circle isso não é necessário porque depois de digitar o raio o comando é encerrado automaticamente não sendo necessário dar um novo ENTER para encerra-lo.

Parece difícil, mas não é quando se entende o procedimento tudo fica mais fácil.

Função COMMAND

Agora com todos os dados em mãos precisamos aprender a utilizar a função command, abaixo segue a sintaxe desse comando:

Sintaxe:

(command <nome do comando em strings> <argumentos do comando em strings>)

Temos ainda alguns argumentos que podemos usar, veja eles abaixo:

pause = pausa o comando esperando uma ação do usuário

“” (duas aspas duplas) = equivale a um ENTER do teclado

Vamos agora dar continuidade no nosso exemplo que é criar um circulo com raio de 10 e altera-lo para a cor vermelha, vamos fazer esse exemplo duas vezes, na segunda vez vamos aprimora-lo fazendo com que o mesmo fique mais funcional e aumente a velocidade do nosso novo comando.

Agora faremos uso de tudo aqui que anotamos e aquilo que aprendermos nessa aula.

Primeiro vamos criar a primeira linha de programação, aquela que eu pedi para vocês decorarem.

(defun c:cv()

Essa linha quer dizer que criaremos um comando que se chamara CV, ou seja bastara digitarmos CV na linha de comando para utiliza-lo.

O próximo passo é fazer uso das nossas anotações primeiro do comando circle

1) Digitar o comando circle.

2) Clicar em um ponto qualquer da tela.

3) Digitar o raio.

(command “circle” pause “10”)

Nessa linha utilizamos a função command e digitamos o comando que queremos usar no caso o “circle” cercado por aspas duplas pois como visto na sintaxe o ocomando precisa ser fornecido como strings, depois utilizamos o pause (sem aspas, o pause é sempre sem aspas), o pause quer dizer que a função command aguardará que o usuário clique em um ponto na tela e por ultimo entramos com o raio “10” também como strings, com essa função criaremos um circulo com raio de 10 em qualquer ponto fornecido pelo usuário.

Agora só falta pintar ele de vermelho, para fazer isso vamos fazer uso também das anotações e implementa-las usando a função command.

1) Digitar o comando chprop.

2) Selecionar o objeto.

3) Pressionar ENTER para informar ao Autocad que não vamos mais selecionar nenhum objeto.

4) Digitamos a opção C (de color)

5) Digitamos o numero da cor, no Autocad a cor vermelha e a cor 1 (no final do blog colocarei uma tabela com as 9 primeiras cores do Autocad)

6) Pressionamos ENTER para informar ao comando chprop que não vamos mais mudar nenhuma propriedade do objeto.

(command “chprop” pause “” “c” “1” “”)

Vamos entender essa linha, primeiro digitamos o comando “chprop” como string, depois o pause vai aguardar que o usuário selecione um objeto no nosso caso o circulo, para informar que não vamos mais selecionar nenhum objeto usamos as duas aspas duplas “” que é a mesma coisa que um ENTER, depois entramos com a letra “c” que informara ao comando chprop que queremos mudar a cor do objeto, com o numero “1” vamos fazer com que o objeto selecionado fique com a cor vermelha (no final do blog vou colocar a tabela de cores), para terminar daremos um ENTER usando duas aspas duplas para informar ao comando chprop que não vamos mais alterar o objeto e que queremos que o mesmo seja finalizado.

Agora podemos juntar tudo e montar o nosso comando

(defun c:cv()

(command “circle” pause “10”)

(command “chprop” pause “” “c” “1” “”)

)

Para finalizar as instruções usaremos sempre um parêntese fechando a nossa função CV, apenas decorem isso, mas a frente no curso vamos falar mais sobre isso.

Pronto criamos o nosso primeiro comando, porem vem uma perguntar, será que ele não pode fica melhor, vamos pensar um pouco:

A primeira coisa que foi feita foi criar o circulo, portanto o circulo foi o ultimo objeto criado pelo Autocad, podemos então ao invés de selecionar o circulo (que é ruim pois o danado o usuário pode selecionar um objeto diferente e fazer mal uso do programa) podemos simplesmente usar a função de seleção last para selecionar o ultimo objeto criado tornando o programa mais rápido.

Fazendo essa modificação nosso programa vai ficar assim:

(defun c:cv()

(command “circle” pause “10”)

(command “chprop” “L” “” “c” “1” “”)

)

Note que tiramos o pause do comando chprop pois agora não necessitaremos que o usuário selecione mais o circulo ao invés disso colocamos o “L” (de last) para selecionar o ultimo objeto e depois as duas aspas duplas para dizer que não vamos selecionar mais nada.

Duas dicas que podem ajudar vocês quando forem se aventurar criando seus comandos:

1) Para não se confundirem se precisam ou não usar as aspas duplas pensem da seguinte forma:

Quando uso um comando preciso pressionar enter para ativa-lo como ele esta cercado por aspas duplas (strings) as duas aspas duplas corresponderam ao enter automático o enter só precisara ser usado quando em suas anotações você deu enter sem ter anotado nada ai será necessário usar aspas duplas.

2) Anote tudo e faça os seus comando em linha de comando, mesmo que você saiba usar o visual lisp ou que tenha digitado em um bloco de notas e carregado com o comando appload, fazer os comando nessa etapa do curso em linha de comando vai fazer com que vocês errem e refaçam varias vezes mesmo um simples comando forçando que vocês se acostumem com as mensagens de erro e ao mesmo tempo forçando vocês a repetirem tudo de novo varias e varias vezes, tipo karate kid.

Na próxima aula continuaremos falando desse assunto e vamos criar novos comandos explorando cada vez mais esse recurso, a ideia é fazer com que vocês treinem muito antes de passarmos para o próximo assunto.

Abaixo segue o link para assistirem essa vídeo aula em nosso canal do Manual de Cad no youtube:

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

Abaixo segue a tabela contendo as oito primeiras cores do Autocad.

Tabela de Cores
Vermelho	1
Amarelo	2
Verde	3
Cian	4
Azul	5
Magenta	6
Branco	7
Cinza	8

Espero que tenham gostado

Sergio Fernandes

Manual de Cad.

terça-feira, 17 de fevereiro de 2015

Aula 8–Manipulando Listas- Parte 2

Olá Pessoal, vamos dar continuidade à aula de manipulação de listas, hoje aprenderemos novas funções de manipulação de listas que em conjunto com o CAR e o CDR nos permitem conseguir qualquer valor dentro de uma lista de forma bem fácil.

Função REVERSE

A função reverse inverte uma lista

Sintaxe:

(reverse <lista>)

Exemplo 1:

(setq lista (list 1 2 3 4 5))

Retornara a lista (1 2 3 4 5)

(setq inverso (reverse lista))

Retornará a lista invertida (5 4 3 2 1)

Exemplo 2:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq inverso (reverse lista))

Retornará ((4 5 6) 3 2 1)

ATENÇÃO: A função reverse inverte os elementos da lista principal não invertendo os dados das sub-listas como no exemplo acima.

Função LAST

A função last pega o ultimo elemento de uma lista.

Sintaxe:

(last <lista>)

Exemplo:

(setq lista (list 1 2 3 4 5))

Retornara a lista (1 2 3 4 5)

(setq ultimo (last lista))

Retornará 5 que é o ultimo elemento da lista.

Função Length

Retorna o número de elementos de uma lista

Sintaxe:

(length <lista>)

Exemplo:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq contagem (length lista))

Retornará 4 como sendo o número de itens dessa lista.

ATENÇÃO: Apesar de parecer que essa lista tem 6 elementos ela não tem, ela tem 3 números inteiros e uma lista, a função length não conta elementos dentro das sub-listas.

Função NTH

Retorna o elemento da lista que se encontra em determinada posição.

Antes de mostra a sintaxe e o exemplo de como funciona essa função precisamos entender uma coisa, o indexador, tudo em Autolisp quando o assunto é indexador precisamos sempre lembrar que o indexador inicial é sempre o zero, se, por exemplo, tivermos uma lista com cinco elementos o indexador do primeiro elemento será o zero e do ultimo elemento será 4.

Sintaxe:

(nth <indexador> <lista>)

Exemplo 1:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq valor (nth 2 lista))

Retornara o valor 3 que é o elemento referente ao indexador 2.

Exemplo 2:

(setq valor (nth 3 lista))

Retornará o valor (4 5 6) que é o elemento referente ao indexador 3.

Exemplo 3:

(setq valor (nth 1 (nth 3 lista)))

Retornará o valor 5, vamos entender a linha de programação desse exemplo, primeiro devemos interpretar (nth 3 lista) que retornara (4 5 6), depois falamos para pegar o indexador 1 desse resultado na lista (4 5 6) o indexador 1 é referente ao valor 5.

Função APPEND

A função append junta as listas fornecidas.

Sintaxe:

(append <lista1> <lista2> . . .)

Exemplo 1:

(setq lista1 (list 1 2 3 4 5))

Retornará (1 2 3 4 5)

(setq lista2 (list “a” “b” “c”))

Retornará (“a” “b” “c”)

(setq lista_nova (append lista1 lista2))

Retornara (1 2 3 4 5 ”a” “b” “c”)

Exemplo 2:

(setq lista1 (list 1 2 3 4 5))

Retornará (1 2 3 4 5)

(setq lista2 (list “a” “b” “c”))

Retornará (“a” “b” “c”)

(setq lista_nova (append lista2 lista1)); Note que inverti a ordem das listas nesse exemplo

Retornara (”a” “b” “c” 1 2 3 4 5)

Nesse exemplo podemos notar que a ordem das listas na função append pode modificar o layout final da lista.

Voltaremos a falar sobre essa função mais a frente, pois quando estivermos falando sobre loopings precisaremos dar uma revisada nessa função.

Função MEMBER

A função member verifica se um determinado elemento esta contido dentro da lista. Caso a função member encontre o item dentro da lista ele retornara o restante da lista a partir do item encontrado, caso ele não encontre o item ele retornara NIL.

Sintaxe:

(member <elemento> <lista>)

Exemplo 1:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq localiza (member 3 lista))

Retornara (3 (4 5 6)) que é o restante da lista a partir do elemento encontrado

Exemplo 2:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq localiza (member 4 lista))

Retornará nil, isso mesmo nil, mesmo o elemento 4 existindo na lista. Isso acontece porque a função member realiza a pesquisa apenas na lista principal não estendendo a busca as sub-listas e é exatamente o nosso caso pois o número 4 encontra-se dentro de outra lista.

Exemplo 3:

(setq lista (list 1 2 3 (list 4 5 6)))

Retornara a lista (1 2 3 (4 5 6))

(setq localiza (member (list 4 5 6) lista))

Retornara ((4 5 6)), ele retornou a lista principal com o restante da lista a partir do item encontrado por isso teremos uma lista dentro da outra.

Espero que tenham gostado na próxima aula faremos os nosso primeiros programas criaremos os nosso primeiros comandos.

Exercicios

1) Monte a lista abaixo em seguida execute as manipulações conforme solicitado.

( 1 2 3 4 5 (“a” “b” “c”) 5 6 7 8 9 10 (( “mario” “amanda” “carlos”) 20 25 30))

Monte as seguintes linhas de programação, sempre guardando o resultado delas em alguma variável de sua escolha:

a) Informe o número de itens da lista

b) Pegue o quinto elemento da lista

c) Verifique se o elemento 10 existe dentro da lista

d) Pegue o ultimo elemento da lista

e) Inverta lista

f) Crie a seguinte lista (“pato” “macaco” 12) e adicione-a a lista

g) Usando apenas duas funções de manipulação e sem usar a função last pegue o ultimo elemento da lista

h) Usando apenas dois comandos de manipulação de listas pegue o valor “b” da lista, não pode utilizar nem CAR nem CDR nem nenhuma fusão deles.

i) Usando apenas duas funções de manipulação e sem usar a função last e sem usar as funções que usou no exercício G pegue o ultimo elemento da lista

j) Usando no máximo 3 comandos de manipulação diferentes extraia o valor “mario” da lista, não pode utilizar nem CAR nem CDR nem nenhuma fusão deles.

Espero que tenham gostado.

Assista também a essa aula em nosso canal Manual de Cad no Youtube.

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

Sérgio Fernandes

Manual de Cad

sábado, 14 de fevereiro de 2015

Aula 7–Manipulando Listas- Parte 1

Olá pessoal, hoje vamos aprender a manipular os dados de uma lista, existem diversas ferramentas em Autolisp para a manipulação de listas, vamos dar inicio aprendendo as duas funções mais básicas do Autolisp o CAR e o CDR.

Funções CAR e CDR

A função CAR retorna o primeiro item da lista.

A função CDR retorna a lista sem o primeiro item, preste atenção no que eu vou escrever e mais a frente entenderemos melhor, “o resto de uma lista ainda é uma lista”, grave bem isso.

Vamos ver alguns exemplos e vamos discutir cada um deles, primeiro vou montar uma lista que usaremos em alguns exemplos.

(setq lista (list “A” “B” “C” (list 1 2 3 4 5)))

O resultado dessa lista será (“A” “B” “C” (1 2 3 4 5))

1) Exemplo

Nesse primeiro exemplo vamos pegar o primeiro elemento dessa lista, ou seja, “A”, para fazer isso devemos fazer uso da função CAR, para facilitar toda vez que fizermos algum exemplo daqui pra frente vamos sempre armazenar o valor dele em uma variável.

(setq primeiro (car lista))

A função car pega apenas o primeiro elemento da lista.

2) Exemplo

Nesse exemplo precisamos pegar o segundo elemento da lista, se você pensou que agora basta usar a função CDR errou, a função CDR retornará o restante da lista sem o primeiro item, e o restante de uma lista sempre será uma lista, então teremos que usar uma combinação de CAR e CDR para pegar o segundo elemento, primeiro faremos isso de forma separada e depois faremos isso de forma combinada.

(setq resto_lista (cdr lista))

A função CDR vai retornar a lista sem o primeiro item (“B” “C” (1 2 3 4 5)), agora temos uma lista chamada resto_lista contendo a lista sem o seu primeiro item, agora podemos usar a função CAR para pegar o primeiro item dessa lista que acabamos de criar e assim pegarmos o valor “B” que é o segundo elemento da lista original.

(setq segundo (car resto_lista))

Como o primeiro elemento da lista resto_lista é o “B” chegamos ao nosso objetivo.

Mas não precisamos na verdade criar uma nova variável para executar essa operação, podemos fazer tudo em uma única linha de programação.

(setq segundo (car (cdr lista)))

Pronto, o Autolisp vai interpretar isso da seguinte forma, primeiro pegaremos o CDR da lista, ou seja, o resto dela sem o primeiro item e depois pegaremos o CAR desse resultado que nos retornará como valor o “B”.

ATENÇÃO: Se você tiver uma lista com apenas dois elementos, não adianta usar a função CDR achando que já que ele vai remover o primeiro item da lista o que sobrar será o que você necessita, lembre-se o resto de uma lista ainda é uma lista, CDR sempre vai devolver o valor como uma lista, se tiver uma lista (1 2) e usar a função CDR terá como resultado (2) que ainda é uma lista e para ter o valor 2 como número inteiro terá que usar a função CAR para remover esse valor de dentro da lista.

3) Exemplo

Usando ainda a lista que criamos acima a nossa meta agora será pegar o valor 2 da lista, esse será bem mais complicado, pois o valor 2 esta dentro de outra lista, para isso faremos uso de diversas funções CAR e CDR, vamos fazer isso passo a passo, depois faremos isso em uma única linha de programação, não vou guarda-las em variáveis, pois vou formular a logica para que depois possamos desenvolver isso em uma única linha.

(cdr lista)

Retornará (“B” “C” (1 2 3 4 5))

(cdr (cdr lista))

Retornará (“C” (1 2 3 4 5))

(cdr (cdr (cdr lista)))

Retornará ((1 2 3 4 5))

(car (cdr (cdr (cdr lista))))

Retornará (1 2 3 4 5) ATENÇÃO, É DIFERENTE DO RESULTADO ACIMA.

(cdr (car (cdr (cdr (cdr lista)))))

Retornará (2 3 4 5))

(car (cdr (car (cdr (cdr (cdr lista))))))

Retornará 2

Resultado final

(setq valor (car (cdr (car (cdr (cdr (cdr lista)))))))

Bem trabalhoso né, existe uma forma de fazer isso que particularmente não gosto, mas que pode deixar a linha de programação um pouco mais legível.

Formando novas funções com CAR e CDR

Isso que vou ensinar agora não é utilizado pela minha pessoa, eu particularmente acredito que o programador perde mais tempo tentando criar novas funções com CAR e CDR do que utilizando da forma que fizemos acima.

Vamos criar uma lista simples

(setq lista (list 1 2 3 4 5))

Retornará (1 2 3 4 5), uma lista contendo 5 itens.

Agora vamos supor que queremos extrair o valor 4 da lista, uma forma de pegar esse valor seria fazer assim (car (cdr (cdr (cdr lista))), mas o que faremos é combina-los e formar uma nova função.

Para fazer isso precisamos pegar as duas primeiras letras da primeira função que no exemplo acima é o CAR, nesse caso as duas primeiras letras seriam CA e das demais funções pegaremos somente a letra do meio, no exemplo acima são CDR, CDR e CDR, pegando somente a letra do meio teremos D D D, agora basta adicionar um R no final.

Então escrever (car (cdr (cdr (cdr lista))) é a mesma coisa de escrever (cadddr lista), ambos retornarão o valor 4.

Vamos criar uma lista um pouco mais complexa

(setq lista (list (list 1 2 3) (list 4 5 6)))

Retornará ( (1 2 3) (4 5 6) ), ou seja, uma lista que tem dois elementos e esses dois elementos são duas outras listas.

Vamos agora pegar o valor 3 dessa lista, se fizemos passo a passo como foi feito no inicio seria assim:

(car lista)

Retornará (1 2 3)

(cdr(car lista))

Retornará (2 3)

(cdr(cdr(car lista))

Retornará (3), note que o 3 ainda é uma lista, então precisamos tira-lo da lista usando o CAR.

(car (cdr (cdr (Car lista))))

Retornará 2

Guardando em uma variável:

(setq valor (car(cdr(cdr(Car lista)))))

Agora criando uma nova função ficaria assim

(setq valor (caddar lista))

Pegamos as duas letras da primeira função CAR e assim fica CA e depois a letra do meio das demais funções D D A e por fim acrescentamos o R.

Não sei informar qual o limite para isso, mas sei que tem, então tente não utilizar esse método com muitas funções.

Eu não sou muito fã disso, mas esta ai para que quiser usar,

Na próxima aulas aprenderemos mais funções de manipulação de listas.

Abaixo seguem os exercícios.

Crie a seguinte lista

( ( 1 2 3) (“a” “b” “c”) ( ( 10 20 30) ”X” “Y” “Z”) ) )

1) Extraia os valores solicitados abaixo usando as funções CAR e CDR sem criar novas funções.

a) Pegue o valor ( 1 2 3)

c) Pegue o valor (“a” “b” “b”)

b) Pegue o valor (10 20 30)

d) Pegue o valor “X”

e) Pegue o valor “Z”

f) Pegue o valor “Y”

g) Pegue o valor “a”

h) Pegue o valor “c”

i) Pegue o valor “b”

j) Pegue o valor “2”

2) Extraia os valores do exercício acima criando novas funções usando o CAR e CDR.

Assista tambem a video aula em meu canal Manual de Cad no Youtube.

https://www.youtube.com/watch?v=PO1E9GptZXo

Espero que tenham gostado

Sergio Fernandes

Manual de Cad

quinta-feira, 12 de fevereiro de 2015

Aula 6 – Listas – Parte 2

Olá pessoal, vamos dar continuidade no aprendizado das listas, acredito que devemos falar um pouco mais sobre o layout de uma lista, ver mais alguns exemplos de listas complexas e explicar melhor o porquê escolhi determinado layout para a lista.

Vamos criar um exemplo um pouco mais complicado do que o exemplo da aula passada.

Exemplo:

Criarei uma lista que deve armazenar os seguintes dados.

1) O nome do bloco.

2) Seu ponto de Inserção.

3) Nome do layer, cor e tipo de linha.

4) Rotação do Bloco.

5) Escala X Y e Z.

Dependendo da quantidade de blocos de um desenho essa lista pode ser pequena ou enorme, para não dificultar muito vou criar um layout de lista contendo apenas 2 elementos, e ai vou explicar o motivo da escolha desse layout.

( ( “Cota” ( 10 20 0) (“Cota_Arvore” 7 “Continuos”) 63 ( 1 1 1) ) ( “Ponto” ( 100 205 0) (“Ponto_Cotado” 1 “Continuos”) 0 ( 1 1 1) ) )

Ficou difícil de entender não é, para facilitar a visualização vou mostrar como essa lista é visualizada no Visual Lisp que é o editor de programas lisp do Autocad.

Essa é a janele Inspect do Visual lisp, aprenderemos a usar ela mais a frente no curso, agora não entrarei em maiores detalhes, o que nos interessa agora é entender o layout dessa lista.

Na parte de cima temos a lista completa, logo abaixo dela temos duas linhas uma começando com (0) e a outra com (1) , isso apenas indica o numero do elemento da lista, ou seja o primeiro item da lista é o item zero o segundo é o item 1, em Autolisp o identificador de item inicial é sempre o zero, então em uma lista com dois elementos teremos dois itens, o item zero e o item 1.

Em cada um desses itens temos outra lista, ou seja, temos uma lista principal e dentro dela temos duas outras listas contendo diversos tipos de dados ( números, strings e outras listas).

Mas porque eu organizei os dados desse jeito, a ideia é agrupar informações relevantes que facilite não só a manipulação desses dados como também o acesso a eles. Criei uma lista principal e para organizar os dados dentro dela eu criei uma lista contendo os dados do bloco (nome, ponto de inserção, os dados do layer, rotação e escalas do bloco), depois precisei pensar em como organizar esses dados, pensei então em criar uma lista contendo esses dados porem não poderia simplesmente criar uma lista simples com todos os dados jogados lá dentro de qualquer maneira, então resolvi organiza-los da seguinte forma, primeiro item dessa sub lista dentro da lista principal seria o nome do bloco em formato string (texto), as coordenadas X Y e Z foram organizadas dentro de outra lista, os dados do layer também foram organizados como uma lista contendo os dados do nome do layer em string, cor do layer como um numero inteiro e o tipo de linha como string, em seguida inseri a rotação como um numero inteiro e as escalas eu organizei em uma lista contendo os números inteiros das escalas em X Y e Z.

A ideia principal é deixar os dados organizados, quando formos manipular os dados dessa lista poderemos usar funções que aprenderemos que facilitarão quando precisarmos acessar os dados ou criar loopings com eles.

Criando listas

Para criar uma lista podemos fazer uso de duas técnicas, o comando list e o quote (‘) sinal de apostrofo.

Primeiro Método – LIST

Esse é o método que eu utilizo abaixo segue a sintaxe desse comando:

Sintaxe:

(list <item 1> <item 2> …)

Exemplos:

(setq lista (list 1 2 3 4 5))

Retornará o valor (1 2 3 4 5), uma lista contendo esses cinco elementos.

(setq lista (list "cota" (list 10 20 0)))

Retornara o valor (“Cota” (10 20 0)), uma lista contendo dois item , uma string e uma lista.

Veja como seria criar a lista do inicio desse post com o comando list:

(setq lista (list (list "Cota" (list 10 20 0) (list "Cota_Arvore" 7 "Continuos") 63 (list 1 1 1) ) (list "Ponto" (list 100 205 0) (list "Ponto_Cotado" 1 "Continuos") 0 (list 1 1 1))))

Complicado né, mas posso garantir que isso é treino, assista a vídeo aula que ficara mais claro como utilizar esse comando.

Segundo Método – ‘ (quote)

O segundo método é mais simples e faremos uso do sinal de apostrofo (‘) chamado de quote, quando utilizamos o quote montamos a lista da forma que quisermos da mesma forma como queremos que ela seja armazenada.

Exemplos:

(setq lista ‘(1 2 3 4 5))

Retornará o valor (1 2 3 4 5), uma lista contendo esses cinco elementos.

(setq lista ‘("cota" (list 10 20 0))

Retornará o valor (“Cota” (10 20 0)), uma lista contendo dois item , uma string e uma lista. Note que o valor retornado é idêntico ao que foi escrito acima.

Veja como seria criar a lista do inicio desse post com o quote:

(setq a '(("Cota" ( 10 20 0) ("Cota_Arvore" 7 "Continuos") 63 ( 1 1 1) ) ("Ponto" ( 100 205 0) ("Ponto_Cotado" 1 "Continuos") 0 ( 1 1 1))))

Facilita bastante pois o quote retornara uma lista idêntica ao que foi feito, no caso do list o resultado é o mesmo porem um pouco mais complicado. Mas nem sempre poderemos usar o quote para a criação de listas, por esse motivo eu sempre utilizo o comando list.

Vamos ver mais alguns exemplo usando os dois métodos, agora vamos criar algumas variáveis antes e usa-las para criar as listas e ai você entenderá porque o quote nem sempre é a melhor opção.

Variáveis

(setq nome “Carlos”)

(setq num1 10)

(setq num2 20)

(setq num3 30)

(setq lista1 (list 1 2 3 4 5))

Exemplo 1 :

Com list

(setq lista (list num1 num2))

Retornará (10 20)

Com quote

(setq lista ‘(num1 num2))

Retornará (num1 num2)

Veja o exemplo acima, você pensou que o quote retornaria o mesmo valor que o list, porem não podemos utilizar o quote quando precisamos criar uma lista usando o valor de uma variável, quando utilizamos o quote ele apenas retorna o nome da variável sem o seu valor.

Exemplo 2 :

Com list

(setq lista (list (list num1 num2) lista1))

Retornará ( (10 20) (1 2 3 4 5) )

Com Quote

(setq lista ‘(( num1 num2) lista1))

Retornará ((num1 num2)(lista))

Exemplo 3:

Com list

(setq lista (List (list num1 num2 (list num3)) (list lista1)))

Retornará ( ( 10 20 (30) ) ( ( 1 2 3 4 5 ) ) )

Com quote

(setq lista ‘((num1 num2 (num3)) (lista1)))

Retornará ((num1 num2 (num3)) (lista1)))

O quote pareceu muito pratico na criação de listas mas não serve quando o assunto é variável, como em Autolisp tudo gira em torno de variável fica muito difícil utiliza o quote, isso não quer dizer que não o utilizaremos no futuro, mas aconselho nesse inicio do curso aprender a criar listas usando somente o comando list.

Aprendemos a criar listas, na próxima aula aprenderemos como manipular os dados de uma lista.

Exercícios:

1) Usando apenas o comando list crie as listas abaixo e armazene o seu resultado em uma variável qualquer.

a) ( ( 1 2 3 4 5) (“a” “b” “c” “d” “e”) )

B) ( ( ( 1 2 3) (4 5 6) ) ( ( “a” “b” “c”) (“d” “e” “f”) ) )

C) (“a” (“b”) “c” 1 (2) 3 (4))

d) ( ( “casa” (“armário” “mesa” “cadeira) ) (“escritório” (“computador” “servidor”) ) )

2) Usando o quote cria as listas abaixo

a) ( ( 1 2 3 4 5) (“a” “b” “c” “d” “e”) )

B) ( ( ( 1 2 3) (4 5 6) ) ( ( “a” “b” “c”) (“d” “e” “f”) ) )

C) (“a” (“b”) “c” 1 (2) 3 (4))

d) ( ( “casa” (“armário” “mesa” “cadeira) ) (“escritório” (“computador” “servidor”) ) )

3) Crie as variáveis abaixo em seguida crie as listas da forma que foi solicitada, execute esse exercício usando o comando list.

Variáveis

(setq a 1)

(setq b 10)

(setq c 100)

(setq nome “Carlos”)

(setq casa “Cadeira”)

(setq quarto “Cama”)

a) ( ( 1 100) ( 10 “Cadeira”))

B) ( (1) (10) (100) ( ( “Cadeira”) ) )

C) ( ( (“Cadeira” 100 (10) ) (“Carlos” 1 (100) ) ) “Cama” )

Assista também a essa aula em nosso canal Manual de Cad no Youtube.

Sérgio Fernandes

Manual de Cad

sexta-feira, 30 de janeiro de 2015

Aula 5–Listas–Parte 1

Olá pessoal, chegamos hoje ao assunto mais importante do nosso curso. Você deve estar pensando que tudo que aprendemos até agora não pode ser aplicado em nada, isso é verdade, o mesmo vai acontecer com as listas, vamos aprender, mas por enquanto não conseguiremos aplicar em nada. Mas tudo que vimos até agora é necessário antes de começarmos a criar programas. De tudo aquilo que foi visto até agora as listas são, sem sombra de dúvida, o mais importante e imprescindível para o Autolisp.

Teremos quantas aulas forem necessárias para que vocês consigam entender como criar e como manipular uma lista. Não sei ao certo ainda quantas aulas serão, conforme eu for escrevendo e gravando as aulas terei uma ideia melhor da quantidade necessária.

O que é uma lista

Não adianta nada ensinar como se cria uma lista se não entendermos antes como é uma lista e como a mesma é utilizada em Autolisp. Uma lista nada mais é do que um conjunto de dados. Em uma lista podemos abrigar diversos tipos de dados, número, textos e até mesmo listas. Podemos criar uma lista da forma que desejarmos, assim podemos organizar os dados da lista de forma a facilitar a manipulação dos mesmos.

Vamos começar com um exemplo de lista simples:

(1 2 3 4 5)

Veja o exemplo acima: é uma lista contendo 5 elementos numéricos, do número 1 ao número 5. Quando estamos falando de texto sabemos que uma variável é numérica ou texto porque os textos são cercados por aspas duplas; no caso das listas elas começam e terminam com parênteses.

Vamos ver outro exemplo:

(“A” “B” “C”)

No exemplo acima temos uma lista simples contendo 3 elementos. São 3 textos “A” “B” “C”.

Agora vamos ver um exemplo diferente, mas também bem simples:

(“A” 1 2 3 “B” 4 5 6 “C”)

Essa lista mescla dois tipos diferentes de dados: numéricos e strings (textos). Essa lista contém 9 elementos, sendo 6 numéricos e 3 strings.

Preste bem atenção no exemplo abaixo:

( ( “A” “B” “C”) (“D” “E” “F”) )

Essa lista possui apenas dois elementos. Isso mesmo, dois elementos e não seis. Temos dentro dessa lista mais duas listas, cada uma das listas possui 3 objetos, mas a lista principal possui apenas 2 elementos que são as duas listas. Vamos ver um exemplo um pouco mais complexo.

No exemplo abaixo criarei uma lista mais complexa armazenando os seguintes dados:

nome idade altura peso

O que vamos fazer agora é analisar a melhor maneira para a criação dessa lista até chegarmos ao resultado final.

Uma das alternativas iniciais é criar simplesmente uma lista com esses dados (Não aprendemos ainda como se cria uma lista, estamos apenas entendendo como ela funciona, logo falaremos sobre esse assunto).

( “Carlos” 30 1.60 68 “Andre” 22 2.65 22 “Jorge” 44 1.66 90)

Pronto, montamos uma lista, mas será que montamos da melhor maneira? Vamos pensar um pouco: se um dia você quiser pegar os dados, por exemplo, do Andre, vai ter que saber obrigatoriamente a posição dos dados. Para tentar resolver esse problema podemos montar essa lista de uma forma diferente.

( (“Carlos” 30 1.60 68) (“Andre” 22 2.65 22) (“Jorge” 44 1.66 90) )

Aparentemente a nossa lista agora ficou mais organizada. Agora temos uma lista com 3 elementos e cada elemento dessa lista é outra lista contendo, cada uma, 4 elementos. Mesmo assim, o que parece ter ficado melhor pode não ter ficado assim tão bom, podemos deixar ainda melhor.

( ( “Carlos” (30 1.60 68) ) (“Andre” (22 2.65 22) )(“Jorge” (44 1.66 90) ) )

Calma lá, como isso pode ter ficado melhor? Agora temos os mesmos 3 elementos na lista, porém agora em cada uma das listas temos dois elementos, um desses elementos é o nome e o outro elemento é uma lista contendo 3 elementos, e esses elementos são os dados da pessoa. Ficou difícil? Vamos ver a ilustração abaixo, ela pode nos ajudar.

Na verdade, o que parece ter ficado pior na verdade ficou melhor. Agora, quando você precisar consultar os dados do Andre, basta fazer o seguinte: achar a lista pertencente ao Andre e pegar o segundo elemento de sua lista, que contém os seus dados. Organizar uma lista de forma a manipular os dados de forma mais fácil é de extrema importância em Autolisp.

Nessa aula sobre lista aprendemos apenas como funciona a estrutura de uma lista, na próxima aula veremos mais alguns exemplos de listas complexas e vamos aprender a criar as listas.

Assista também essa aula em nosso canal Manual de Cad no youtube.

Não faremos exercícios nessa aula, pois não terminamos de aprender ainda como se cria uma lista. Os exercícios estarão disponíveis na próxima aula.

Sergio Fernandes

Manual de Cad

segunda-feira, 26 de janeiro de 2015

Aula 4–Operações Matemáticas–Parte 2

Olá pessoal, vamos dar continuidade na nossa aula sobre operações matemáticas, apreenderemos hoje mais algumas funções matemáticas e veremos como cada uma se comporta. Apesar de ser um número grande de funções todas são de fácil entendimento.

Função ABS

Essa função retorna o valor absoluto de um número, para quem não sabe o valor absoluto é o valor do próprio número desprezando o sinal a sua frente.

Sintaxe: (abs <número>)

Exemplos:

(setq num –100)

(abs num)

Criamos uma variável num com o valor negativo 100, usando a função abs o programa retornara como valor o número 100 desprezando o sinal de menos.

(setq num –123.44)

(setq dec (abs num))

Criamos uma variável num com o valor negativo –123.44, usando a função abs o programa retornara como valor o número 123.44 desprezando o sinal de menos e diferente do exemplo acima esse valor será armazenado na variável dec.

Função SQRT

Essa função retorna a raiz quadrada de um número, essa função sempre retornara como valor um número decimal, mesmo que a raiz seja exata.

Sintaxe: (sqrt <número>)

Exemplos:

(setq num 100)

(setq raiz (sqrt num))

Criamos uma variável num com o valor inteiro 100, em seguida criamos a variável raiz que terá como valor 10.0 (número decimal), note que mesmo a raiz sendo exata a função sqrt retornara como valor um número decimal.

(setq num 23)

(setq raiz (sqrt num))

Criamos uma variável num com o valor inteiro 23, em seguida criamos a variável raiz que terá como valor 4.79583 (número decimal), diferente do exemplo acima o número 23 não possui raiz exata, sendo assim o resultado seria obrigatoriamente um número decimal.

(setq num 23.45)

(setq raiz (sqrt num))

Criamos uma variável num com o valor decimal 23.45, em seguida criamos a variável raiz que terá como valor 4.84252 (número decimal), nesse exemplo mostramos apenas que é possível extrair raiz quadradas de número decimais.

Função EXPT

Essa função retorna um número elevado a outro número. O resultado poderá ser um valor inteiro ou decimal.

Sintaxe: (expt <número da base> <número do expoente>)

Exemplos:

(setq base 2)

(setq expoente 3)

(setq valor (expt base expoente))

Criamos uma variável base com o valor 2 e uma variável expoente com valor 3, ao usarmos a função expt dizemos ao computador que queremos o resultado de 2 elevado ao cubo e isso retornara o valor 8.

(setq valor (expt 10 2))

Retornara o valor inteiro 100, pois estamos elevando 10 ao quadrado.

(setq valor (expt 3.0 2))

Retornara o valor decimal 9.0, pois estamos elevando 3.0 (decimal) ao quadrado.

(setq valor (expt 4 3.45))

Retornara o valor decimal 119.428, pois estamos elevando o número inteiro 4 ao valor decimal 3.45.

Função LOG

Retorna o logaritmo natural de um número.

Sintaxe: (log <número>)

Exemplo:

(log 4)

Retorna o valor 1.38629.

Função GCD

Essa função retorna o máximo divisor comum (m.d.c.) entre dois números.

Sintaxe: (gcd <número1> <número2>)

Exemplo:

(setq val (gcd 14 21))

Ele retornara 7 que é o máximo divisor comum entre os dois números.

Função MAX

Retorna o maior número entre os números fornecidos.

Sintaxe: (max <número1> <número2> . . .)

Exemplo:

(setq maior (max 1 2 3 4 5 10 25))

Retornará o número 25 que é o maior dos números fornecidos.

Função MIN

Retorna o menor número entre os números fornecidos.

Sintaxe: (min <número1> <número2> . . .)

Exemplo:

(setq menor (min 1 2 3 4 5 10 25))

Retornará o número 1 que é o menor dos números fornecidos.

Função PI

Retorna o valor de Pi, essa função na verdade é uma constante numérica que pode usar usada em qualquer calculo.

Exemplo:

(* pi 2)

Retornara o valor de PI multiplicado por 2, 6.28 aproximadamente.

Funções Trigonométricas

Função SIN

Retornará o seno do angulo fornecido, esse angulo deve ser fornecido em radianos.

Sintaxe: (sin < angulo em radianos>)

Exemplo:

(setq seno (sin (/ pi 2)))

Retornará 1.0 que é o valor do seno de PI dividido por 2, note que o valor retornado é sempre um valor decimal.

Função COS

Retorna o co-seno do angulo fornecido, esse angulo deve ser fornecido em radianos.

Sintaxe: (cos < angulo em radianos>)

Exemplo:

(setq coseno (cos 0.5))

Retornará 0.877583 que é o valor do co-seno de 0.5.

Tangente

Não existe uma função para o calculo de tangente em Autolisp, quando necessitamos dela precisamos executar esse calculo manualmente dividindo o seno pelo co-seno do angulo.

Exemplo:

(setq tangente (/ (sin 0.5) (cos 0.5))

Retornara 0.546302 que é a tangente desse angulo.

Assista essa aula também em nosso canal Manual de Cad no youtube:

Sérgio Fernandes

Manuel de Cad.