Pró-Reitoria de Graduação Curso de Engenharia Civil Trabalho de Conclusão de Curso

Transcrição

1 Pró-Reitoria de Graduação Curso de Engenharia Civil Trabalho de Conclusão de Curso ELABORAÇÃO DE UM PROGRAMA AUTOCAD PARA CÁLCULO E DETALHAMENTO DE LAJES MACIÇAS RETANGULARES Autores: Gabriel Costa de Oliveira e Thalles Morais Faria Orientador: Profº. DSc. Miguel Enrique Genovese Soares Brasília - DF 2014

2 GABRIEL COSTA DE OLIVEIRA THALLES MORAIS FARIA ELABORAÇÃO DE UM PROGRAMA NO AUTOCAD PARA CÁLCULO E DETALHAMENTO DE LAJES MACIÇAS RETANGULARES. Trabalho apresentado à Graduação em Engenharia Civil da Universidade Católica de Brasília, como requisito de aprovação no Trabalho de Conclusão de Curso. Orientador: Profº. DSc. Miguel Enrique Genovese Soares Brasília 2014

3 Artigo de autoria de Gabriel Costa de Oliveira e Thalles Morais Faria, intitulado ELABORAÇÃO DE UM PROGRAMA NO AUTOCAD PARA CÁLCULO E DETALHAMENTO DE LAJES MACIÇAS RETANGULARES, apresentado como requisito parcial para obtenção do grau de Bacharel em Engenharia Civil da Universidade Católica de Brasília, em 9 de junho de 2014, defendido e aprovado pela banca examinadora abaixo assinada: Profº. DSc. Miguel Enrique Geovenese Soares Orientador Curso de Engenharia Civil UCB Profª. MSc. Glauceny Cirne de Medeiros Examinador Curso de Engenharia Civil UCB Brasília 2014

4 1 ELABORAÇÃO DE UM PROGRAMA NO AUTOCAD PARA CÁLCULO E DETALHAMENTO DE LAJES MACIÇAS RETANGULARES GABRIEL COSTA DE OLIVEIRA THALLES MORAIS FARIA RESUMO Este trabalho apresenta o programa computacional elaborado para calcular e detalhar, dentro do ambiente de AutoCAD, lajes maciças em concreto armado. O AutoLISP é uma linguagem de programação dentro do AutoCAD que permite a elaboração de programas. Trabalhando apenas dentro do AutoCAD, retira-se da cadeia de produção a utilização de outros tipos de programas como: ftool, eberick, entre outros, agilizando o processo. Ainda mais que, ao importamos dados de um programa w para um programa z, nem sempre esses dados são lidos corretamente pelo programa z. Por exemplo, os softwares comerciais quase sempre falham no detalhamento quando existem particularidades como ângulos não retos, furos, etc. O detalhamento da laje é determinado pelo software em questão, que: controla flechas, dimensiona a flexão mediante os momentos fletores nos eixos x e y. Dessa maneira se obtém o diâmetro da bitola do aço, o número de barras e o espaçamento entre elas. Finalmente, o software monta o detalhamento dos ferros e a tabela de aço. Palavras-chave: Programação. AutoCAD. AutoLISP. Laje.

5 2 1. INTRODUÇÃO Há alguns anos, antes da invenção dos microcomputadores e posteriormente à invenção de programas computacionais e softwares, os cálculos de estruturas eram feitos à mão, o que tomava muito tempo dos engenheiros. Cálculos que antes poderiam levar meses são hoje feitos em poucas horas por computadores. O papel do engenheiro não se tornou menos importante após a invenção dos computadores e seus programas. Esse tem o papel de introduzir corretamente os dados iniciais no programa e deve ser capaz de ler os resultados e analisar se esses estão condizentes ou não com o trabalho realizado. Os softwares devem ser apenas ferramentas de facilitação e de agilidade dos serviços. O AutoCAD (Computer Aided Design ou Desenho Auxiliado por Computador é um dos programas mais utilizados na engenharia civil. Ele é capaz de fazer desenhos 2D, 3D e possui mais uma série de funções importantes. Mas o interessante é que dentro dele existe uma ferramenta, o ambiente AutoLISP de programação, que possibilita ao usuário realizar programas, assim podendo criar softwares capazes de realizar diferentes funções, como a apresentada neste artigo. 1.1.Lajes O concreto armado, utilizado nas lajes, é um dos materiais mais empregados na construção civil em todo o mundo. Tendo em vista que o concreto tem a característica de suportar grandes cargas à compressão e o aço é capaz de suportar grandes cargas à tração, juntos eles formam um conjunto único, capaz de suportar grandes carregamentos. O concreto é um produto da mistura de água, cimento, agregados e eventualmente, aditivos. A combinação e a devida proporção desses elementos dirá se a estrutura de concreto terá maior ou menor capacidade de carga. Para a formação de um sistema estrutural, é preciso que elementos estruturais interajam entre si, como: lajes, vigas, pilares, fundações e etc, formando um todo. Ou seja, para a construção de um edifício é necessário que lajes trabalhem junto a vigas, que trabalhem junto a pilares e que trabalhem junto a fundação e, a relação e o arranjo entre todos esses em conjunto formará um sistema estrutural. Segundo a NBR 6118/2003 lajes são classificadas como: elementos de superfície plana (placas sujeitos principalmente a ações normais a seu plano. Estas possuem duas dimensões maiores: largura e comprimento e uma terceira dimensão menor: a espessura. Feitas de concreto e aço, elas devem ser capazes de suportar ações perpendiculares a ela,

6 3 transmitido na maioria das vezes às vigas. As lajes podem trabalhar engastadas, apoiadas ou com bordo livre, dependendo da continuidade e da forma como são armadas. Dentro das ações que atuam em uma laje, devem ser consideradas: as cargas permanentes, as cargas lineares e as cargas acidentais. Cargas permanentes são cargas estáticas na laje e distribuídas uniformemente sobre ela. São consideradas cargas permanentes: peso próprio da laje, contra piso, piso, etc. Cargas lineares também são cargas estáticas na laje, porém essas são distribuídas linearmente sobre ela. Uma parede sobre uma laje é um exemplo de carga linear. Cargas acidentais são cargas que dependem da finalidade para que fora construído o edifício. São exemplos de cargas acidentais: pessoas andando sobre a laje, móveis, máquinas, entre outros. Existem atualmente diversos tipos de laje, como: lajes maciças, lajes nervuradas, lajes pré-moldadas, lajes cogumelo, lajes treliçadas, entre outras. O foco do presente trabalho são as lajes maciças. Geralmente moldadas in loco, essas, apesar de consumirem bastante concreto e fôrma de madeira, e possuírem elevado peso próprio, são de fácil execução e largamente utilizadas na construção civil AutoLISP A Autodesk, desenvolvedora de softwares para design de produtos, projetos arquitetônicos e produção de conteúdo digital, fundada por John Walker e 12 outros cofundadores em 1982, a história da empresa, com sede em San Rafael, Califórnia, se confunde com a história do AutoCAD. A versão 2.1 introduziu um conceito inovador na indústria de softwares CAD: a plataforma aberta, com a introdução de um intérprete embutido baseada na linguagem de programação Lisp, o AutoLISP, com dialeto adaptado para programar soluções específicas no AutoCAD. Além disso, foi implementado um subsistema de bibliotecas em linguagem C, que foi disponibilizado aos programadores. Isso possibilitou o surgimento de um grande número de pequenas empresas desenvolvedoras de aplicativos complementares para o AutoCAD, que funcionava de forma semelhante a um sistema operacional específico. Desde então, a Autodesk se beneficiou bastante do trabalho desses desenvolvedores ao redor do mundo e passou comprar as empresas mais promissoras e prolíficas no desenvolvimento de

7 4 melhorias para o AutoCAD. ( consultado em 10/05/ MATERIAIS E MÉTODOS 2.1.Materiais Para a realização deste artigo, os seguintes materiais foram utilizados: Computador; Calculadora; Ferramentas do Microsoft Office; AutoCAD Métodos Entrada no Ambiente de programação AutoLISP O passo a passo para entrar no ambiente de programação dentro do AutoCAD ocorre da seguinte maneira: abrindo-se o CAD, na barra de ferramentas de sua tela inicial, poderá ser visualizada a opção Tools ; esta opção abrirá uma série de ferramentas, dentre elas, a opção AutoLISP ; clicando-se em AutoLISP, haverá a opção Visual LISP Editor (Figura 1, que, por fim, se clicada, abrirá o ambiente de programação (Figura 2 em questão dentro do AutoCAD.

8 5 Figura 1: Entrado no AutoLISP - passo a passo Figura 2: Ambiente AutoLISP Execução do programa Dentro do ambiente AutoCAD, o usuário precisará digitar um comando para que o programa comece a rodar. No caso, o comando utilizado foi LAJE. 1º passo: Desenho da laje;

9 6 2º passo: Clique em três pontos (quinas consecutivos da laje; 3º passo: O programa detecta qual o (menor tamanho e qual o (maior tamanho; 4º passo: Tendo os dois comprimentos da laje, divide-se o pelo, obtendo-se o lambda. Nesse programa o não poderá ser maior que 2. Portanto, serão calculadas apenas lajes armadas em duas direções. Pois, sendo o maior do que 2, a laje é armada em apenas uma direção. (CARVALHO, R. C. Cálculo e detalhamento de estruturas usuais de concreto armado. EsUFSCar, 2010, p. 303; 5º passo: Após o cálculo do, obtém-se os coeficientes: alfax, utilizado para o cálculo do momento no eixo x; alfay, utilizado para o cálculo do momento no eixo y; e alfa2, utilizado para o cálculo da flecha. Todos esses coeficientes podem ser encontrados na tabela tipo 1 (Laje com os quatro bordas livremente apoiadas de momentos fletores. (Tabelas de Czerny Beton-Kalender (1976 coeficiente de Poisson ν= 0,2; 6º passo: O usuário escolhe a espessura de sua laje (h. A proposta mínima para a espessura é de 7 cm, portanto, caso o usuário digite uma espessura menor, o programa fará um loopping, fazendo com que o programa só prossiga caso o usuário digite um número maior do que 7. Apesar de a espessura mínima para lajes ser 5 cm (lajes de cobertura (NBR 6118:2003 Item , adotou-se 7 cm como espessura mínima, pois o programa calcula apenas lajes para piso; 7º passo: Multiplicando-se a espessura da laje pelo peso específico do concreto armado (25KN/, é possível calcular seu peso próprio (p; 8º passo: A carga acidental (carga variável é digitada pelo usuário em (KN/ ; 9º passo: Pelo somatório da carga acidental e peso próprio, obtém-se a carga total ( atuante na laje em (KN/ ; 10º passo: Tendo o, o e o, pela equação (Tabelas de Czerny Beton- Kalender (1976 coeficiente de Poisson ν= 0,2, calcula-se o momento no eixo x. Tendo o, o e o, pela equação (Tabelas de Czerny Beton-Kalender (1976 coeficiente de Poisson ν= 0,2, calcula-se o momento no eixo y. E por fim, tendo o, o, o, o módulo de deformabilidade do concreto (E e o h, pela equação,

10 7 calcula-se a flecha máxima. (Tabelas de Czerny Beton-Kalender (1976 coeficiente de Poisson ν= 0,2; 11º passo: Obtendo-se os momentos característicos, estes são multiplicados por um fator de segurança equivalente a 1,4 (Tabela 11.2 e 12.1 da NBR 6118:2003; o que é chamado de momento de projeto ( ; 12º passo: O usuário digitará a resistência do concreto desejada, que posteriormente será utilizada para a leitura da tabela (Elaborado por Alessandro L. Nascimento e Libânio M. Pinheiro de acordo com a NBR 6118:2003; 13º passo: Ocorre no programa a verificação da altura mínima da laje de acordo com o momento aplicado a ela (CARVALHO, R. C. Cálculo e detalhamento de estruturas usuais de concreto armado. EsUFSCar, 2010, p Caso a altura não passe, o programa informará ao usuário e o fará voltar pedindo para que aumente a espessura de sua laje; 14º passo: Com o valor do momento fletor, da espessura da laje e sabendo que o cálculo se dará para cada metro de laje, ou seja, d igual a 100 cm, pela equação (Elaborado por Alessandro L. Nascimento e Libânio M. Pinheiro de acordo com a NBR 6118:2003, obtém-se o valor de. E pela equação (Elaborado por Alessandro L. Nascimento e Libânio M. Pinheiro de acordo com a NBR 6118:2003, obtém-se o ; 15º passo: Para este programa, utilizou-se o aço CA-50; 16º passo: Com o e a devida característica do aço, obtém-se em tabela o. (Elaborado por Alessandro L. Nascimento e Libânio M. Pinheiro de acordo com a NBR 6118:2003; 17º passo: Pela equação (Elaborado por Alessandro L. Nascimento e Libânio M. Pinheiro de acordo com a NBR 6118:2003, determina-se a área de aço; 18º passo: De acordo com a tabela (Elaborado por Alessandro L. Nascimento e Libânio M. Pinheiro de acordo com a NBR 7480:1996; conforme o item da NBR 6118:2003, o programa disponibilizará opções de bitolas de aço no eixo x, de acordo com as faixas de

11 8 área de aço encontradas, para que então o usuário possa escolher a bitola que melhor o atenda. O mesmo procedimento ocorrerá para o aço no eixo y ; 19º passo: O detalhamento da armadura de aço aparecerá na tela, no meio da laje, em cima de uma linha perpendicular a direção em que o aço será armado, contendo sucessivamente as seguintes informações: o número de barras, o número (nome da barra, a bitola, o espaçamento entre elas e o seu comprimento; 20º passo: No final de todo esse processo, o usuário terá a opção de continuar o programa para que calcule novas lajes, ou poderá encerrá-lo. Caso o usuário decida continuar os cálculos, o programa utilizará a mesma espessura de laje, a mesma sobrecarga e a mesma resistência do concreto. Caso queira calcular lajes com especificações diferentes, o usuário deverá sair do programa e entrar novamente; 21º passo: Caso o usuário deseje saber o quadro de aço, ele deverá digitar o comando QUADRO. O programa agrupa as barras de aço de acordo com a bitola e o comprimento, sendo esses iguais, eles terão o mesmo nome; 22º passo: Por último, ao digitar QUADRORESUMO, o usuário obterá em tela um quadro resumo com o peso total do aço e seu comprimento total de acordo com cada bitola. 3. RESULTADOS E DISCUSSÃO 3.1.RESULTADOS Aproximação e Verificação com resultados de 3 lajes de dimensões diferentes: Foram simuladas 3 lajes (Figura 3 e calculadas. Primeiramente os cálculos foram feitos à mão e em seguida com o programa (LAJE V1.0, para que ocorresse sua validação. Todas as lajes são consideradas como simplesmente apoiadas (Tipo 1.

12 9 Figura 3: Lajes DADOS DE ENTRADA: LAJE 1 LAJE 2 LAJE 3 (m 5,5 2 2 (m 6,3 3,3 3 Espessura (cm Fck (MPa Carga acidental (KN/ Tabela 1: Entrada de dados no programa LAJE - V1.0

13 Cálculos feitos a mão: Laje 1 Laje com dimensões 6,3 x 5,5m: 1 Cálculo do lambda: 2 Cálculo do Peso Próprio: = 3 Cálculo da Carga total: 4 Cálculo do Momento e Área de Aço no Eixo x: /m 5 Cálculo do Momento e Área de Aço no Eixo y: /m 6 Flecha máxima:

14 Laje 2 Laje com dimensões 3,3 x 2m: 1 Cálculo do lambda: 2 Cálculo do Peso Próprio: = 3 Cálculo da Carga total: 4 Cálculo do Momento e Área de aço no Eixo x: /m 5 Cálculo do Momento e Área de Aço no Eixo y: /m 6 Flecha máxima:

15 Laje 3 Laje com dimensões 3 x 2m: 1 Cálculo do lambda: 2 Cálculo do Peso Próprio = 3 Cálculo da Carga total 4 Cálculo do Momento e Área de Aço no Eixo x: /m 5 Cálculo do Momento e Área de Aço no Eixo y: /m 6 Flecha máxima:

16 Cálculos feitos pelo software: Laje 1 1 Carga TOTAL = 8,0 KN/m² 2 Momento no eixo x: 12, Momento de projeto no eixo x: 17,5544 : 22,7863 Área de aço x: 2,01876 cm² 4 Momento no eixo y: 10,852 Momento de projeto no eixo y: 15,1928 : 26,3282 Área de aço y: 1,74717 cm²/m 5 Flecha máxima: 1,82553 mm

17 Laje 2 1 Carga TOTAL = 3,75 KN/m² 2 Momento no eixo x: 1, Momento de projeto no eixo x: 1,82609 : 26,8333 Área de aço x: 0,6 cm² 4 Momento no eixo y: 0, Momento de projeto no eixo y: 0, : 54,8333 Área de aço y: 0, cm²/m 5 Flecha máxima: 0, mm

18 Laje 3 1 Carga TOTAL = 5,5 KN/m² 2 Momento no eixo x: 1, Momento de projeto no eixo x: 2,33333 : 42,8571 Área de aço x: 0, cm² 4 Momento no eixo y: 0, Momento de projeto no eixo y: 1,32189 : 75,6494 Área de aço y: 0, cm²/m 5 Flecha máxima: 0, mm Após lançado os dados no AutoCad é apresentado na tela a laje detalhada (Figura 4. Digitando quadro na barra de comandos do AutoCad, será exibido na tela a tabela de aço (Tabela 2, o mesmo acontece com o quadro resumo (Tabela 3 quando é digitado na barra de comandos quadroresumo.

19 16 Figura 4: Lajes detalhadas POSIÇÃO (N Ø (mm Comprimento (cm Quantidade Total (cm N N N N N Tabela 2: Tabela de Aço

20 17 Ø (mm 5 6,3 TOTAL Comprimento (m Peso (kg 114, ,9 112, ,6 Tabela 3: Quadro resumo 3.2.DISCUSSÃO Comparação de Resultados 3 (Tabela 6. A seguir os comparativos dos resultados da Laje 1 (Tabela 4, Laje 2 (Tabela 5 e Laje LAJE 1 Resultados - cálculos a mão Resultados - software Erros percentuais (% Carga total (KN/m² (KNm/m 17,55 17,5544 0,44 (KNm/m 15,19 15,1928 0,28 (cm²/m 2,02 2, ,124 (cm²/m 1,75 1, ,283 (mm 1,82 1, ,553 Tabela 4: Resultados LAJE 1

21 18 LAJE 2 Resultados - cálculos a mão Resultados - software Erros percentuais (% Carga total (KN/m² 3,75 3,75 0 (KNm/m 1,764 1, ,209 (KNm/m 0,896 0, ,2383 (cm²/m 0,58 0,6 2,00 (cm²/m 0,29 0, ,3617 (mm 0,707 0, ,0711 Tabela 5: Resultados LAJE 2 LAJE 3 Resultados - cálculos a mão Resultados - software Erros percentuais (% Carga total (KN/m² 5,5 5,5 0 (KNm/m 2,338 2, ,4667 (KNm/m 1,316 1, ,589 (cm²/m 0,54 0, ,3333 (cm²/m 0,3 0, ,4034 (mm 0,28 0, ,8489 Tabela 6: Resultados LAJE 3 Os resultados finais dos cálculos feitos à mão não coincidiram exatamente com os do programa, porém ficaram bem próximos. Pode-se concluir que a pequena diferença entre os resultados se deu apenas por questões de arredondamento e do número de casas decimais utilizadas nos cálculos.

22 19 4. CONCLUSÃO E RECOMENDAÇÕES 4.1.CONCLUSÃO Ao analisarmos os resultados dos cálculos feitos à mão e dos cálculos feitos pelo software, foi possível concluir que o algoritmo de programação trabalha bem próximo ao método utilizado (Método elástico para cálculo de lajes maciças e de acordo com algumas normas brasileiras (NBR de estruturas de concreto, em que o software foi baseado. Portanto, a ideia de criar o LAJE V1.0, dentro do CAD, capaz de automatizar o detalhamento estrutural de lajes maciças, se tornou uma solução muito interessante, tendo até uma maior precisão nos resultados por utilizar maior número de casas decimais. Além dos três testes exaltados no trabalho, foram feitos mais uma bateria de testes para que o programa fosse validado. Entretanto, apesar de tantos testes feitos, o programa não é 100% confiável, necessitando que ainda mais testes sejam realizados. Apesar de o programa calcular apenas lajes com as quatro bordas livremente apoiadas, armaduras mínimas negativas podem ser colocadas para evitar as possíveis fissurações que ocorrerão no apoio da laje na viga. 4.2.RECOMENDAÇÕES Este trabalho foi apenas um pequeno passo dado para o cálculo e detalhamento de lajes no AutoCAD, podendo futuramente o programa ser desenvolvido, para que assim esse possa: fazer o detalhamento de lajes armadas em uma direção; calcular os momentos negativos da laje e fazer compatibilização de momentos, podendo assim ser feito o cálculo da armadura negativa; calcular não somente lajes retangulares, mas também lajes de formas geométricas diferentes; calcular outros 8 tipos lajes maciças com vinculações de borda diferentes; calcular outros tipo de laje, como, por exemplo, a nervurada; calcular e fazer o detalhamento de outros elementos estruturais, como: vigas, pilares, fundações e etc.

23 20 DESIGN OF A COMPUTER PROGRAM INSIDE AUTOCAD TO THE CALCULATION AND DETAILMENT OF MASSIVE RETANGULAR SLABS Author: Gabriel Costa de Oliveira e Thalles Morais Faria Advisor: DSc. Miguel Henrique Genovese Soares ABSTRACT This work presents a computer program designed to calculate and detail, inside de AutoCad environment, massive slabs of reinforced concrete. The AutoLISP is a programming language inside the AutoCAD that allows the design of programs. Working just inside de AutoCAD, we can cut of from the production chain the use of other types of programs such as: ftool, eberick, among others, speeding up the proccess. Further more, when we import data from program w to program z, these data are not always correctly read by the program z. For example, the commercial softwares often fail to detail when some particularities exists such as straight angles, holes, etc. The detailment of the slab is determined by the software in question, which: controls arrows, dimensions the flexion with the bending moments on the x and y axes. Thus we can obtain the gauge steel diameter, the number of bars and the spacing between them. Finally, the software builds the detailment of the irons and the steel table. Key-words: Programming. AutoCad. AutoLISP. Slab.

24 21 REFERÊNCIAS ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 6118: projeto de estruturas de concreto Procedimento. Rio de Janeiro, ASSOCIAÇÃO BRASILEIRA DE NORMAS TÉCNICAS. NBR 6120: cargas para o cálculo de estruturas de edificações Procedimento. Rio de Janeiro AUTODESK. Autodesk. Disponível em: < Acesso em: 10/05/2014 CARVALHO, R. C.; FIGUEIREDO FILHO, J. R. Cálculo e detalhamento de estruturas usuais de concreto armado: segundo a NBR 6118: ed. São Carlos: EsUFSCar, MOREIRA, M. E. Autodesk completa 30 anos com muita história para contar. Bdxpert Disponível em: < Acesso em: 10/05/2014. PINHEIRO, L.M. (1993 Concreto armado: tabelas e ábacos. São Carlos. Escola de Engenharia de São Carlos, USP. USP EESC Departamento de Engenharia de Estruturas Lajes maciças. Lajes maciças. Libânio M. Pinheiro, Cassiane D. Muzardo, Sandro P. Santos. Fec Disponível em: < Acesso em: 17/03/2014.

25 1 ANEXO (defun c:laje( (setq momentox nil (setq momentoy nil (setq momentoxd nil (setq momentoyd nil (setq kcx nil (setq kcy nil (setq validacaoresistencia nil (setq auxres nil (setq Acox nil (setq Acoy nil (setq opt1x nil (setq opt2x nil (setq opt3x nil (setq opt1y nil (setq opt2y nil (setq opt3y nil (setq AreaAcox nil (setq AreaAcoy nil (setq Bitx nil (setq NBarrasx nil (setq Bity nil (setq NBarrasy nil (setq espacex nil (setq espacey nil (setq TotalBarrasx nil

26 2 (setq TotalBarrasy nil (setq cargaacidental nil auxres nil (setq Dmin nil (setq ManterDados T contvezes 0 (while (equal ManterDados T (setq ORTOMODE (getvar "orthomode"; armazena valor ORTHOMODE (setvar "orthomode" 0 ; desabilita bloqueio ortogonal (setq pt1 (getpoint "\nselecione o primeiro ponto da laje: " (setq pt2 (getpoint pt1 "\nselecione o segundo ponto da laje: " (setq pt3 (getpoint pt2 "\nselecione o terceiro ponto da laje: " (setq distancia1 (distance pt1 pt2 (setq distancia2 (distance pt2 pt3 (princ "\n" ;pega o valor do menor lado (if (< distancia1 distancia2 (progn ;ly maior vao (setq ly distancia2 ;menor vao (setq lx distancia1 (progn ;ly maior vao

27 3 (setq ly distancia1 ;menor vao (setq lx distancia2 ;lambida (setq lamb (/ ly lx (if (> lamb 2 (princ "Erro : Lâmbida maior que 2." (progn ;variaveis dependentes de lambida (cond ((<= lamb 1.05 (setq alfax 22.7 alfay 22.7 alfa ((<= lamb 1.10 (setq alfax 20.8 alfay 22.5 alfa ((<= lamb 1.15 (setq alfax 19.3 alfay 22.3 alfa ((<= lamb 1.20 (setq alfax 18.1 alfay 22.3 alfa ((<= lamb 1.25 (setq alfax 16.9 alfay 22.3 alfa ((<= lamb 1.30 (setq alfax 15.9 alfay 22.4 alfa ((<= lamb 1.35 (setq alfax 15.2 alfay 22.7 alfa ((<= lamb 1.40 (setq alfax 14.4 alfay 22.9 alfa ((<= lamb 1.45 (setq alfax 13.8 alfay 23.1 alfa ((<= lamb 1.50 (setq alfax 13.2 alfay 23.3 alfa ((<= lamb 1.55 (setq alfax 12.7 alfay 23.5 alfa2 11.2

28 4 ((<= lamb 1.60 (setq alfax 12.3 alfay 23.5 alfa ((<= lamb 1.65 (setq alfax 11.9 alfay 23.5 alfa ((<= lamb 1.70 (setq alfax 11.5 alfay 23.5 alfa ((<= lamb 1.75 (setq alfax 11.2 alfay 23.5 alfa2 9.8 ((<= lamb 1.80 (setq alfax 10.8 alfay 23.5 alfa2 9.5 ((<= lamb 1.85 (setq alfax 10.7 alfay 23.5 alfa2 9.3 ((<= lamb 1.90 (setq alfax 10.4 alfay 23.5 alfa2 9.1 ((<= lamb 1.95 (setq alfax 10.2 alfay 23.5 alfa2 8.9 ((<= lamb 2.00 (setq alfax 10.1 alfay 23.5 alfa2 8.7 (setq Dmin 0 (while (OR (= Dmin 0 (> Dmin (* hlaje 100 (if (or (and (equal ManterDados T (= contvezes 0 (> Dmin (* hlaje 100 (progn ;altura / espessura da laje (setq hlaje (/ (getreal "\ndigite a espessura da laje em (cm: " (while (< hlaje 0.07 (princ "\n Espessura mínima da laje igual a 7cm! \n" (setq hlaje nil (setq hlaje (/ (getreal "\n Digite a espessura da laje em (cm: "

29 5 ;calculo das cargas atuantes (if (and (equal ManterDados T (= contvezes 0 (progn ;peso proprio (setq PesoProprio (* hlaje 25 ;carga acidental (if (= cargaacidental nil " (setq cargaacidental (getreal "\ninsira a sobre carga em (KN/m²: (princ "\ncarga acidental : " (princ cargaacidental (princ " KN/m²" (princ "\npeso Próprio: " (princ PesoProprio (princ " KN/m²" (setq cargatotal (+ cargaacidental PesoProprio (princ "\ncarga TOTAL = Carga acidental + Peso Próprio : " (princ cargatotal (princ " KN/m²" (progn (princ "\ncarga acidental : "

30 6 (princ cargaacidental (princ " KN/m²" (princ "\npeso Próprio: " (princ PesoProprio (princ " KN/m²" (princ "\ncarga TOTAL = Carga acidental + Peso Próprio : " (princ cargatotal (princ " KN/m²" ;tentativa de achar o momento no eixo x (setq momentox (* cargatotal lx lx (/ 1 alfax (princ "\nmomento no eixo x: " (princ momentox ;tentativa de achar o momento no eixo y (setq momentoy (* cargatotal lx lx (/ 1 alfay (princ "\nmomento no eixo y: " (princ momentoy ;calculo do momento de de projeto no eixo x (setq momentoxd (* momentox 1.4 (princ "\nmomento de projeto no eixo x: " (princ momentoxd ;calculo do momento de de projeto no eixo y (setq momentoyd (* momentoy 1.4

31 7 (princ "\nmomento de projeto no eixo y: " (princ momentoyd ;calculo do kcx (setq kcx (/ (* hlaje hlaje (* momentoxd ;calculo do kcy (setq kcy (/ (* hlaje hlaje (* momentoyd (princ "\nkcx: " (princ kcx (princ "\nkcy: " (princ kcy (if (and (equal ManterDados T (= contvezes 0 (progn ;resistencia concreto (if (= auxres nil (setq validacaoresistencia nil (setq validacaoresistencia T (while (equal validacaoresistencia nil : " (setq auxres (getint "\ndigite a resistência do concreto em MPa (

32 8 (cond ((= auxres 20.0 (setq validacaoresistencia T ((= auxres 25.0 (setq validacaoresistencia T ((= auxres 30.0 (setq validacaoresistencia T ((= auxres 35.0 (setq validacaoresistencia T ((= auxres 40.0 (setq validacaoresistencia T ;calculo da flexa maxima (setq E (/ (* 0.85 (* 5600 (sqrt auxres10 (setq flexa (* 1000 (/ (* cargatotal lx lx lx lx (* (* hlaje hlaje hlaje alfa2 E10000 (princ "\nflexa máxima: " (princ flexa (princ " mm" ;busca ksx (setq Acox (KS auxres kcx (setq Acoy (KS auxres kcy ;calculo da area de aco x (setq AreaAcox (/ (* Acox momentoxd (* hlaje (princ "\nárea de aço x: " (princ AreaAcox (princ " cm²"

33 9 (setq opt1x nil opt2x nil opt3x nil (cond ((<= AreaAcox 0.79(setq opt1x (list 5 4 (list 8 4 (list (list 10 4 ((<= AreaAcox 0.98(setq opt1x (list 5 5 opt3x (list ((<= AreaAcox 1.18(setq opt1x (list 5 6 opt2x (list ((<= AreaAcox 1.25(setq opt1x (list opt2x (list 5 7 ((<= AreaAcox 1.37(setq opt1x (list 5 7 opt2x (list ((<= AreaAcox 1.56(setq opt1x (list opt2x (list 5 8 ((<= AreaAcox 1.57(setq opt1x (list 5 8 opt3x (list ((<= AreaAcox 1.77(setq opt1x (list 5 9 opt2x (list ((<= AreaAcox 1.87(setq opt1x (list opt2x (list 5 10 opt3x ((<= AreaAcox 1.96(setq opt1x (list 5 10 opt2x (list 8 4 opt3x ((<= AreaAcox 2.01(setq opt1x (list 8 4 opt2x (list ((<= AreaAcox 2.18(setq opt1x (list opt3x (list 8 5 ((<= AreaAcox 2.49(setq opt1x (list opt2x (list 8 5 ((<= AreaAcox 2.51(setq opt1x (list 8 5 opt2x (list ((<= AreaAcox 2.81(setq opt1x (list opt2x (list 8 6 ((<= AreaAcox 3.02(setq opt1x (list 8 6 opt2x (list opt3x

34 10 (list 8 7 (list (list 8 10 (list 10 7 (list (list 16 4 (list ((<= AreaAcox 3.12(setq opt1x (list opt2x (list 10 4 opt3x ((<= AreaAcox 3.14(setq opt1x (list 10 4 opt2x (list 8 7 ((<= AreaAcox 3.52(setq opt1x (list 8 7 opt2x (list 10 5 ((<= AreaAcox 3.93(setq opt1x (list 10 5 opt2x (list 8 8 ((<= AreaAcox 4.02(setq opt1x (list 8 8 opt3x (list 10 6 ((<= AreaAcox 4.52(setq opt1x (list 8 9 opt2x (list 10 6 opt3x ((<= AreaAcox 4.71(setq opt1x (list 10 6 opt2x (list opt3x ((<= AreaAcox 4.91(setq opt1x (list opt2x (list 8 10 opt3x ((<= AreaAcox 5.03(setq opt1x (list 8 10 opt2x (list 10 7 opt3x ((<= AreaAcox 5.5(setq opt1x (list 10 7 opt2x (list ((<= AreaAcox 6.14(setq opt1x (list opt2x (list 10 8 ((<= AreaAcox 6.28(setq opt1x (list 10 8 opt3x (list 12.5 ((<= AreaAcox 7.07(setq opt1x (list 10 9 opt2x (list ((<= AreaAcox 7.36(setq opt1x (list opt2x (list opt3x ((<= AreaAcox 7.85(setq opt1x (list opt2x (list 16 4 opt3x ((<= AreaAcox 8.04(setq opt1x (list 16 4 opt2x (list ((<= AreaAcox 8.59(setq opt1x (list opt3x (list 16 5

35 11 opt3x (list 20 4 (list 16 7 (list 22 4 (list 20 5 (list 16 8 (list 22 5 (list 25 4 (list (list 20 7 (list 22 6 (list 25 5 (list 20 8 ((<= AreaAcox 9.82(setq opt1x (list opt2x (list 16 5 ((<= AreaAcox 10.05(setq opt1x (list 16 5 opt2x (list ((<= AreaAcox 11.04(setq opt1x (list opt2x (list 16 6 ((<= AreaAcox 12.06(setq opt1x (list 16 6 opt2x (list ((<= AreaAcox 12.27(setq opt1x (list opt2x (list 20 4 opt3x ((<= AreaAcox 12.57(setq opt1x (list 20 4 opt2x (list 16 7 opt3x ((<= AreaAcox 14.07(setq opt1x (list 16 7 opt2x (list 22 4 opt3x ((<= AreaAcox 15.21(setq opt1x (list 22 4 opt2x (list 20 5 opt3x ((<= AreaAcox 15.71(setq opt1x (list 20 5 opt2x (list 16 8 ((<= AreaAcox 16.08(setq opt1x (list 16 8 opt3x (list 20 6 ((<= AreaAcox 18.1(setq opt1x (list 16 9 opt2x (list 20 6 opt3x ((<= AreaAcox 18.85(setq opt1x (list 20 6 opt2x (list 22 5 opt3x ((<= AreaAcox 19.01(setq opt1x (list 22 5 opt2x (list 25 4 opt3x ((<= AreaAcox 19.63(setq opt1x (list 25 4 opt2x (list opt3x ((<= AreaAcox 20.11(setq opt1x (list opt2x (list 20 7 opt3x ((<= AreaAcox 21.99(setq opt1x (list 20 7 opt2x (list 22 6 opt3x ((<= AreaAcox 22.81(setq opt1x (list 22 6 opt2x (list 25 5 opt3x

36 12 (list 22 7 (list 25 6 (list 22 8 (list (list 32 4 (list 22 9 (list 25 7 (list 32 5 (list 40 4 (list 32 7 ((<= AreaAcox 24.54(setq opt1x (list 25 5 opt2x (list 20 8 opt3x ((<= AreaAcox 25.13(setq opt1x (list 20 8 opt2x (list 22 7 ((<= AreaAcox 26.61(setq opt1x (list 22 7 opt2x (list 20 9 opt3x ((<= AreaAcox 28.27(setq opt1x (list 20 9 opt2x (list 25 6 opt3x ((<= AreaAcox 29.45(setq opt1x (list 25 6 opt2x (list 22 8 opt3x ((<= AreaAcox 30.41(setq opt1x (list 22 8 opt2x (list opt3x ((<= AreaAcox 31.42(setq opt1x (list opt2x (list 32 4 opt3x ((<= AreaAcox 32.17(setq opt1x (list 32 4 opt2x (list 22 9 opt3x ((<= AreaAcox 34.21(setq opt1x (list 22 9 opt2x (list 25 7 ((<= AreaAcox 34.36(setq opt1x (list 25 7 opt2x (list ((<= AreaAcox 38.01(setq opt1x (list opt2x (list 25 8 opt3x ((<= AreaAcox 39.27(setq opt1x (list 25 8 opt2x (list 32 5 ((<= AreaAcox 40.21(setq opt1x (list 32 5 opt2x (list 25 9 ((<= AreaAcox 44.18(setq opt1x (list 25 9 opt2x (list 32 6 ((<= AreaAcox 48.25(setq opt1x (list 32 6 opt2x (list opt3x ((<= AreaAcox 49.09(setq opt1x (list opt2x (list 40 4 opt3x ((<= AreaAcox 50.27(setq opt1x (list 40 4 opt2x (list 32 7

37 13 ((<= AreaAcox 56.3(setq opt1x (list 32 7 opt2x (list 40 5 ((<= AreaAcox 62.83(setq opt1x (list 40 5 opt2x (list 32 8 ((<= AreaAcox 64.34(setq opt1x (list 32 8 opt3x (list 40 6 ((<= AreaAcox 72.38(setq opt1x (list 32 9 opt2x (list 40 6 ((<= AreaAcox 75.4(setq opt1x (list 40 6 opt2x (list ((<= AreaAcox 80.42(setq opt1x (list opt2x (list 40 7 ((<= AreaAcox 87.96(setq opt1x (list 40 7 ((<= AreaAcox 100.5(setq opt1x (list 40 8 ((<= AreaAcox 113.1(setq opt1x (list 40 9 ((<= AreaAcox 125.7(setq opt1x (list opt2x (list ;calculo da area de aco y (setq AreaAcoy (/ (* Acoy momentoyd (* hlaje (princ "\nárea de aço y: " (princ AreaAcoy (princ " cm²" (setq opt1y nil opt2y nil opt3y nil (cond

38 14 ((<= AreaAcoy 0.79(setq opt1y (list 5 4 (list 8 4 (list (list 10 4 (list 8 7 ((<= AreaAcoy 0.98(setq opt1y (list 5 5 opt3y (list ((<= AreaAcoy 1.18(setq opt1y (list 5 6 opt2y (list ((<= AreaAcoy 1.25(setq opt1y (list opt2y (list 5 7 ((<= AreaAcoy 1.37(setq opt1y (list 5 7 opt2y (list ((<= AreaAcoy 1.56(setq opt1y (list opt2y (list 5 8 ((<= AreaAcoy 1.57(setq opt1y (list 5 8 opt3y (list ((<= AreaAcoy 1.77(setq opt1y (list 5 9 opt2y (list ((<= AreaAcoy 1.87(setq opt1y (list opt2y (list 5 10 opt3y ((<= AreaAcoy 1.96(setq opt1y (list 5 10 opt2y (list 8 4 opt3y ((<= AreaAcoy 2.01(setq opt1y (list 8 4 opt2y (list ((<= AreaAcoy 2.18(setq opt1y (list opt3y (list 8 5 ((<= AreaAcoy 2.49(setq opt1y (list opt2y (list 8 5 ((<= AreaAcoy 2.51(setq opt1y (list 8 5 opt2y (list ((<= AreaAcoy 2.81(setq opt1y (list opt2y (list 8 6 ((<= AreaAcoy 3.02(setq opt1y (list 8 6 opt2y (list opt3y ((<= AreaAcoy 3.12(setq opt1y (list opt2y (list 10 4 opt3y

39 15 (list (list 8 10 (list 10 7 (list (list 16 4 (list ((<= AreaAcoy 3.14(setq opt1y (list 10 4 opt2y (list 8 7 ((<= AreaAcoy 3.52(setq opt1y (list 8 7 opt2y (list 10 5 ((<= AreaAcoy 3.93(setq opt1y (list 10 5 opt2y (list 8 8 ((<= AreaAcoy 4.02(setq opt1y (list 8 8 opt3y (list 10 6 ((<= AreaAcoy 4.52(setq opt1y (list 8 9 opt2y (list 10 6 opt3y ((<= AreaAcoy 4.71(setq opt1y (list 10 6 opt2y (list opt3y ((<= AreaAcoy 4.91(setq opt1y (list opt2y (list 8 10 opt3y ((<= AreaAcoy 5.03(setq opt1y (list 8 10 opt2y (list 10 7 opt3y ((<= AreaAcoy 5.5(setq opt1y (list 10 7 opt2y (list ((<= AreaAcoy 6.14(setq opt1y (list opt2y (list 10 8 ((<= AreaAcoy 6.28(setq opt1y (list 10 8 opt3y (list 12.5 ((<= AreaAcoy 7.07(setq opt1y (list 10 9 opt2y (list ((<= AreaAcoy 7.36(setq opt1y (list opt2y (list opt3y ((<= AreaAcoy 7.85(setq opt1y (list opt2y (list 16 4 opt3y ((<= AreaAcoy 8.04(setq opt1y (list 16 4 opt2y (list ((<= AreaAcoy 8.59(setq opt1y (list opt3y (list 16 5 ((<= AreaAcoy 9.82(setq opt1y (list opt2y (list 16 5

40 16 opt3y (list 20 4 (list 16 7 (list 22 4 (list 20 5 (list 16 8 (list 22 5 (list 25 4 (list (list 20 7 (list 22 6 (list 25 5 (list 20 8 (list 22 7 ((<= AreaAcoy 10.05(setq opt1y (list 16 5 opt2y (list ((<= AreaAcoy 11.04(setq opt1y (list opt2y (list 16 6 ((<= AreaAcoy 12.06(setq opt1y (list 16 6 opt2y (list ((<= AreaAcoy 12.27(setq opt1y (list opt2y (list 20 4 opt3y ((<= AreaAcoy 12.57(setq opt1y (list 20 4 opt2y (list 16 7 opt3y ((<= AreaAcoy 14.07(setq opt1y (list 16 7 opt2y (list 22 4 opt3y ((<= AreaAcoy 15.21(setq opt1y (list 22 4 opt2y (list 20 5 opt3y ((<= AreaAcoy 15.71(setq opt1y (list 20 5 opt2y (list 16 8 ((<= AreaAcoy 16.08(setq opt1y (list 16 8 opt3y (list 20 6 ((<= AreaAcoy 18.1(setq opt1y (list 16 9 opt2y (list 20 6 opt3y ((<= AreaAcoy 18.85(setq opt1y (list 20 6 opt2y (list 22 5 opt3y ((<= AreaAcoy 19.01(setq opt1y (list 22 5 opt2y (list 25 4 opt3y ((<= AreaAcoy 19.63(setq opt1y (list 25 4 opt2y (list opt3y ((<= AreaAcoy 20.11(setq opt1y (list opt2y (list 20 7 opt3y ((<= AreaAcoy 21.99(setq opt1y (list 20 7 opt2y (list 22 6 opt3y ((<= AreaAcoy 22.81(setq opt1y (list 22 6 opt2y (list 25 5 opt3y ((<= AreaAcoy 24.54(setq opt1y (list 25 5 opt2y (list 20 8 opt3y

41 17 (list 25 6 (list 22 8 (list (list 32 4 (list 22 9 (list 25 7 (list 32 5 (list 40 4 (list 32 7 ((<= AreaAcoy 25.13(setq opt1y (list 20 8 opt2y (list 22 7 ((<= AreaAcoy 26.61(setq opt1y (list 22 7 opt2y (list 20 9 opt3y ((<= AreaAcoy 28.27(setq opt1y (list 20 9 opt2y (list 25 6 opt3y ((<= AreaAcoy 29.45(setq opt1y (list 25 6 opt2y (list 22 8 opt3y ((<= AreaAcoy 30.41(setq opt1y (list 22 8 opt2y (list opt3y ((<= AreaAcoy 31.42(setq opt1y (list opt2y (list 32 4 opt3y ((<= AreaAcoy 32.17(setq opt1y (list 32 4 opt2y (list 22 9 opt3y ((<= AreaAcoy 34.21(setq opt1y (list 22 9 opt2y (list 25 7 ((<= AreaAcoy 34.36(setq opt1y (list 25 7 opt2y (list ((<= AreaAcoy 38.01(setq opt1y (list opt2y (list 25 8 opt3y ((<= AreaAcoy 39.27(setq opt1y (list 25 8 opt2y (list 32 5 ((<= AreaAcoy 40.21(setq opt1y (list 32 5 opt2y (list 25 9 ((<= AreaAcoy 44.18(setq opt1y (list 25 9 opt2y (list 32 6 ((<= AreaAcoy 48.25(setq opt1y (list 32 6 opt2y (list opt3y ((<= AreaAcoy 49.09(setq opt1y (list opt2y (list 40 4 opt3y ((<= AreaAcoy 50.27(setq opt1y (list 40 4 opt2y (list 32 7 ((<= AreaAcoy 56.3(setq opt1y (list 32 7 opt2y (list 40 5

42 18 ((<= AreaAcoy 62.83(setq opt1y (list 40 5 opt2y (list 32 8 ((<= AreaAcoy 64.34(setq opt1y (list 32 8 opt3y (list 40 6 ((<= AreaAcoy 72.38(setq opt1y (list 32 9 opt2y (list 40 6 ((<= AreaAcoy 75.4(setq opt1y (list 40 6 opt2y (list ((<= AreaAcoy 80.42(setq opt1y (list opt2y (list 40 7 ((<= AreaAcoy 87.96(setq opt1y (list 40 7 ((<= AreaAcoy 100.5(setq opt1y (list 40 8 ((<= AreaAcoy 113.1(setq opt1y (list 40 9 ((<= AreaAcoy 125.7(setq opt1y (list opt2y (list ;verificacao do Dmin (setq Dmin (Dminimo momentoxd momentoyd auxres (if (> Dmin (* hlaje 100 (progn (princ "Dmin > hlaje" (princ "\naltura minima da laje: " (princ Dmin (princ " cm\n"

43 19 ;bitola x (setq validacaobitx nil (while (equal validacaobitx nil (princ "\nselecione uma das opções de bitola para o eixo x (" (if (/= opt1x nil (princ (car opt1x (if (/= opt2x nil (progn (princ " - " (princ (car opt2x (if (/= opt3x nil (progn (princ " - " (princ (car opt3x (princ " :"

44 20 (setq Bitx (getreal (cond ((= Bitx (car opt1x (setq NBarrasx (cadr opt1x validacaobitx T ((= Bitx (car opt2x (setq NBarrasx (cadr opt2x validacaobitx T ((= Bitx (car opt3x (setq NBarrasx (cadr opt3x validacaobitx T ;bitola y (setq validacaobity nil (while (equal validacaobity nil (princ "\nselecione uma das opções de bitola para o eixo y (" (if (/= opt1y nil (princ (car opt1y (if (/= opt2y nil (progn (princ " - " (princ (car opt2y (if (/= opt3y nil (progn (princ " - "

45 21 (princ (car opt3y (princ " :" (setq Bity (getreal (cond ((= Bity (car opt1y (setq NBarrasy (cadr opt1y validacaobity T ((= Bity (car opt2y (setq NBarrasy (cadr opt2y validacaobity T ((= Bity (car opt3y (setq NBarrasy (cadr opt3y validacaobity T ;(princ opt1x (princ "\nnúmero de barras em x igual a: " (princ NBarrasx (princ " barras por metro" (princ "\nnúmero de barras em y igual a: " (princ NBarrasy (princ " barras por metro"

46 22 (setq espacex (/ 100 NBarrasx (setq espacey (/ 100 NBarrasy (setq TotalBarrasx (fix (+ (* NBarrasx lx 0.9 (setq TotalBarrasy (fix (+ (* NBarrasy ly 0.9 (setq pos (agrupa bitx (* lx 100 (princ "\n" (princ bitx (princ "\n" (princ (* lx 100 (if (= pos 0 (progn (setq pos (nmaior ;(princ "\n" ;(princ pos (setq pos2 (agrupa bity (* ly 100 ;(princ "\n" ;(princ pos2

47 23 (if (= pos2 0 (progn (if (and (= bitx bity (= lx ly (setq pos2 pos (setq pos2 (+ pos 1 (progn (setq pos2 (+ pos 1 (progn (setq pos2 (agrupa bity (* ly 100 (if (= pos2 0 (setq pos2 (nmaior C=" (rtos (* lx 100 " C=" (rtos (* ly 100 (setq Textox (strcat (rtos TotalBarrasx " N" (rtos pos " %%C " (rtos Bitx " c/" (rtos espacex " (setq Textoy (strcat (rtos TotalBarrasy " N" (rtos pos2 " %%C " (rtos Bity " c/" (rtos espacey

48 24 ; Inicializacoes (setq ECO (getvar "cmdecho" ; armazena valor CMDECHO (setq ORTO (getvar "orthomode"; armazena valor ORTHOMODE (setq OSN (getvar "osmode" (setvar "cmdecho" 0 ; inibe eco de comando (setvar "orthomode" 1 ; habilita bloqueio ortogonal (setvar "osmode" 0 ;Achar ponto esquerda-inferior (setq X1 (car Pt1 X2 (Car PT2 X3 (Car Pt3 (if (And (<= X1 X2 (<= X1 X3 (setq XI X1 (if (And (<= X2 X1 (<= X2 X3 (setq XI X2 (if (And (<= X3 X1 (<= X3 X2 (setq XI X3 (setq Y1 (cadr Pt1 Y2 (Cadr PT2 Y3 (Cadr Pt3 (if (And (<= Y1 Y2 (<= Y1 Y3

49 25 (setq YI Y1 (if (And (<= Y2 Y1 (<= Y2 Y3 (setq YI Y2 (if (And (<= Y3 Y1 (<= Y3 Y2 (setq YI Y3 ;define os pontos de insercao das escritas (if (/= X1 X2 (progn (setq PT1X (list XI (+ YI (/ distancia2 2 (setq PT2X (list (+ XI distancia1 (+ YI (/ distancia2 2 (setq PT1Y (list (+ XI (/ distancia1 2 YI (setq PT2Y (list (+ XI (/ distancia1 2 (+ YI distancia2 (if (= X1 X2 (progn (setq PT1X (list XI (+ YI (/ distancia1 2 (setq PT2X (list (+ XI distancia2 (+ YI (/ distancia1 2 (setq PT1Y (list (+ XI (/ distancia2 2 YI

50 26 (setq PT2Y (list (+ XI (/ distancia2 2 (+ YI distancia1 (princ "\ndistancia 1\n" (princ distancia1 (princ "\ndistancia 2\n" (princ distancia2 (if(/= X1 X2 (progn (if (<= distancia1 distancia2 (progn (command "_.line" PT1X PT2X "" (command "_.line" PT1Y PT2Y "" (command "_.text" PT1X Textox (command "_.text" PT1Y Textoy

51 27 (if (> distancia1 distancia2 (progn (command "_.line" PT1X PT2X "" (command "_.line" PT1Y PT2Y "" (command "_.text" PT1X Textoy (command "_.text" PT1Y Textox (if(= X1 X2 (progn (if (<= distancia1 distancia2 (progn (command "_.line" PT1X PT2X "" (command "_.line" PT1Y PT2Y "" (command "_.text" PT1X Textoy

52 28 (command "_.text" PT1Y Textox (if (> distancia1 distancia2 (progn (command "_.line" PT1X PT2X "" (command "_.line" PT1Y PT2Y "" (command "_.text" PT1X Textox (command "_.text" PT1Y Textoy ; Inicializacoes off (setvar "cmdecho" ECO ; inibe eco de comando (setvar "orthomode" ORTO ; habilita bloqueio ortogonal (setvar "osmode" OSN

53 29 (setq validamanter nil (while (equal validamanter nil (setq ManterDados (getstring "\ndeseja manter dados e calcular outra laje? <S/N>" (cond ((or (equal ManterDados "N" (equal ManterDados "n"(setq ManterDados nil validamanter T ((or (equal ManterDados "S" (equal ManterDados "s"(setq ManterDados T validamanter T (setq contvezes (+ contvezes 1 (setvar "orthomode" ORTOMODE ; habilita bloqueio ortogonal (princ ; limpa finalizacao de funcao (defun KS (AuxRes kc (if (= auxres 20 (cond ((>= kc 51.9 (setq Aco 0.023

54 30 ((>= kc 26.2 (setq Aco ((>= kc 17.6 (setq Aco ((>= kc 13.3 (setq Aco ((>= kc 10.7 (setq Aco ((>= kc 09.0 (setq Aco ((>= kc 07.8 (setq Aco ((>= kc 06.9 (setq Aco ((>= kc 06.2 (setq Aco ((>= kc 05.6 (setq Aco ((>= kc 05.1 (setq Aco ((>= kc 04.7 (setq Aco ((>= kc 04.4 (setq Aco ((>= kc 04.1 (setq Aco ((>= kc 03.9 (setq Aco ((>= kc 03.7 (setq Aco ((>= kc 03.5 (setq Aco ((>= kc 03.3 (setq Aco ((>= kc 03.2 (setq Aco ((>= kc 03.1 (setq Aco ((>= kc 03.0 (setq Aco ((>= kc 02.9 (setq Aco ((>= kc 02.8 (setq Aco ((>= kc 02.7 (setq Aco ((>= kc 02.7 (setq Aco ((>= kc 02.6 (setq Aco ((>= kc 02.5 (setq Aco ((>= kc 02.4 (setq Aco ((>= kc 02.4 (setq Aco 0.030

55 31 ((>= kc 02.3 (setq Aco ((>= kc 02.3 (setq Aco ((>= kc 02.2 (setq Aco ((>= kc 00.0 (setq Aco (if (= auxres 25 (cond ((>= kc 41.5 (setq Aco ((>= kc 20.9 (setq Aco ((>= kc 14.1 (setq Aco ((>= kc 10.6 (setq Aco ((>= kc 8.6 (setq Aco ((>= kc 7.2 (setq Aco ((>= kc 6.2 (setq Aco ((>= kc 5.5 (setq Aco ((>= kc 4.9 (setq Aco ((>= kc 4.5 (setq Aco ((>= kc 4.1 (setq Aco ((>= kc 3.8 (setq Aco ((>= kc 3.5 (setq Aco ((>= kc 3.3 (setq Aco ((>= kc 3.1 (setq Aco ((>= kc 3.0 (setq Aco ((>= kc 2.8 (setq Aco 0.027

56 32 ((>= kc 2.7 (setq Aco ((>= kc 2.6 (setq Aco ((>= kc 2.5 (setq Aco ((>= kc 2.4 (setq Aco ((>= kc 2.3 (setq Aco ((>= kc 2.3 (setq Aco ((>= kc 2.2 (setq Aco ((>= kc 2.1 (setq Aco ((>= kc 2.1 (setq Aco ((>= kc 2.0 (setq Aco ((>= kc 2.0 (setq Aco ((>= kc 1.9 (setq Aco 0.03 ((>= kc 1.9 (setq Aco 0.03 ((>= kc 1.8 (setq Aco 0.03 ((>= kc 1.8 (setq Aco ((>= kc 00.0 (setq Aco (if (= auxres 30 (cond ((>= kc 34.6 (setq Aco ((>= kc 17.4 (setq Aco ((>= kc 11.7 (setq Aco ((>= kc 8.9 (setq Aco ((>= kc 7.2 (setq Aco 0.024

57 33 ((>= kc 6.0 (setq Aco ((>= kc 5.2 (setq Aco ((>= kc 4.6 (setq Aco ((>= kc 4.1 (setq Aco ((>= kc 3.7 (setq Aco ((>= kc 3.4 (setq Aco ((>= kc 3.2 (setq Aco ((>= kc 3.0 (setq Aco ((>= kc 2.8 (setq Aco ((>= kc 2.6 (setq Aco ((>= kc 2.5 (setq Aco ((>= kc 2.3 (setq Aco ((>= kc 2.2 (setq Aco ((>= kc 2.1 (setq Aco ((>= kc 2.0 (setq Aco ((>= kc 2.0 (setq Aco ((>= kc 1.9 (setq Aco ((>= kc 1.9 (setq Aco ((>= kc 1.8 (setq Aco ((>= kc 1.8 (setq Aco ((>= kc 1.7 (setq Aco ((>= kc 1.7 (setq Aco ((>= kc 1.6 (setq Aco ((>= kc 1.6 (setq Aco 0.03 ((>= kc 1.5 (setq Aco 0.03 ((>= kc 1.5 (setq Aco 0.03 ((>= kc 1.5 (setq Aco ((>= kc 0.0 (setq Aco 0.031

58 34 (if (= auxres 35 (cond ((>= kc 29.7 (setq Aco ((>= kc 15.0 (setq Aco ((>= kc 10.1 (setq Aco ((>= kc 7.6 (setq Aco ((>= kc 6.1 (setq Aco ((>= kc 5.2 (setq Aco ((>= kc 4.5 (setq Aco ((>= kc 3.9 (setq Aco ((>= kc 3.5 (setq Aco ((>= kc 3.2 (setq Aco ((>= kc 2.9 (setq Aco ((>= kc 2.7 (setq Aco ((>= kc 2.5 (setq Aco ((>= kc 2.4 (setq Aco ((>= kc 2.2 (setq Aco ((>= kc 2.1 (setq Aco ((>= kc 2.0 (setq Aco ((>= kc 1.9 (setq Aco ((>= kc 1.8 (setq Aco ((>= kc 1.8 (setq Aco ((>= kc 1.7 (setq Aco 0.028

59 35 ((>= kc 1.6 (setq Aco ((>= kc 1.6 (setq Aco ((>= kc 1.6 (setq Aco ((>= kc 1.5 (setq Aco ((>= kc 1.5 (setq Aco ((>= kc 1.4 (setq Aco ((>= kc 1.4 (setq Aco ((>= kc 1.4 (setq Aco 0.03 ((>= kc 1.3 (setq Aco 0.03 ((>= kc 1.3 (setq Aco 0.03 ((>= kc 1.3 (setq Aco ((>= kc 0.0 (setq Aco (if (= auxres 40 (cond ((>= kc 25.9 (setq Aco ((>= kc 13.1 (setq Aco ((>= kc 8.8 (setq Aco ((>= kc 6.7 (setq Aco ((>= kc 5.4 (setq Aco ((>= kc 4.5 (setq Aco ((>= kc 3.9 (setq Aco ((>= kc 3.4 (setq Aco ((>= kc 3.1 (setq Aco 0.025

60 36 ((>= kc 2.8 (setq Aco ((>= kc 2.6 (setq Aco ((>= kc 2.4 (setq Aco ((>= kc 2.2 (setq Aco ((>= kc 2.1 (setq Aco ((>= kc 2.0 (setq Aco ((>= kc 1.8 (setq Aco ((>= kc 1.8 (setq Aco ((>= kc 1.7 (setq Aco ((>= kc 1.6 (setq Aco ((>= kc 1.5 (setq Aco ((>= kc 1.5 (setq Aco ((>= kc 1.4 (setq Aco ((>= kc 1.4 (setq Aco ((>= kc 1.4 (setq Aco ((>= kc 1.3 (setq Aco ((>= kc 1.3 (setq Aco ((>= kc 1.3 (setq Aco ((>= kc 1.2 (setq Aco ((>= kc 1.2 (setq Aco 0.03 ((>= kc 1.2 (setq Aco 0.03 ((>= kc 1.1 (setq Aco 0.03 ((>= kc 1.1 (setq Aco ((>= kc 0.0 (setq Aco 0.031

61 37 (setq Acox Aco (defun Dminimo (momentoxd momentoyd auxres (if (>= momentoxd momentoyd (setq maior momentoxd menor momentoyd (setq maior momentoyd menor momentoxd (setq Dmin (fix (+ (sqrt (/ (* maior 100 (/ (* auxres (defun Agrupa (bitola comprimento (setq Luprec (getvar "luprec" (setvar "luprec" 0 (setq listss (ssget "_A" '((0. "Text" ;selectiona todos os texts do projeto (setq Ndado 0 (setq contador 0;contador dos texts (setq erro nil;erro para quando achar bitola e comprimento iguais. (if (/= listss nil (progn

62 38 (WHILE (and (< contador (sslength listss (= erro nil contador; pega a lista que contem (1. Texto (setq text (car(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr (entget (ssname listss (setq text (cdr text; pega somente o texto do list ;verifica se o escrito eh de laje (setq contadortext 1 (while (and (< contadortext (strlen text (/= " " (substr text contadortext 1 (setq contadortext (+ contadortext 1 (if (equal "N" (substr text (+ contadortext 1 1 (progn ;inicio logica de achar bitola (setq contadortext 1 (setq qtdesp 0 (while (< qtdesp 3 (if (equal " " (substr text contadortext 1 (setq qtdesp (+ qtdesp 1 (setq contadortext (+ contadortext 1 (setq qtddigitos 1 (setq contadortextfim (+ contadortext 1

63 39 (while (/= " " (substr text contadortextfim 1 (setq contadortextfim (+ contadortextfim 1 (setq qtddigitos (+ qtddigitos 1 (setq Bit (atof (substr text contadortext qtddigitos ;fim da logica de achar bitola ;inicio logica de achar o comprimento (setq contadortext (+ contadortext qtddigitos (setq qtdesp 0 (while (< qtdesp 2 (if (= " " (substr text contadortext 1 (setq qtdesp (+ qtdesp 1 (setq contadortext (+ contadortext 1 (setq qtddigitos 1 (setq contadortextfim (+ contadortext 1 (while (< contadortextfim (strlen text (setq contadortextfim (+ contadortextfim 1 (setq qtddigitos (+ qtddigitos 1

64 40 (setq Comp (atof (substr text (+ contadortext 2 qtddigitos ;fim da logica de achar comprimento ;inicio logica de verificacao de agrupamento de dados (if (and (= Bit bitola (= comp comprimento (progn (setq erro T (setq contadorn 1 (while (/= " " (substr text contadorn 1 (setq contadorn (+ contadorn 1 (setq contadortextfim (+ contadorn 1 (setq qtddigitos 1 (while (/= " " (substr text contadortextfim 1 (setq contadortextfim (+ contadortextfim 1 (setq qtddigitos (+ qtddigitos 1 (setq NDado (atoi (substr text (+ contadorn 2 qtddigitos

65 41 ;fim logica de verificacao de agrupamento de dados (setq contador (+ contador 1 (setvar "luprec" Luprec (setq Ndado Ndado (defun Nmaior( (setq maior 0 (setq Luprec (getvar "luprec" (setq listss (ssget "_A" '((0. "Text" ;selectiona todos os texts do projeto (setq contador 0;contador dos texts (if (/= listss nil (progn (WHILE (< contador (sslength listss contador; pega a lista que contem (1. Texto (setq text (car(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr(cdr (entget (ssname listss (setq text (cdr text; pega somente o texto do list (setq contadortext 1 (while (and (< contadortext (strlen text (/= " " (substr text contadortext 1 (setq contadortext (+ contadortext 1 (if (equal "N" (substr text (+ contadortext 1 1

66 42 (progn (setq contadortextfim (+ contadortext 1 (setq qtddigitos 1 (while (/= " " (substr text contadortextfim 1 (setq contadortextfim (+ contadortextfim 1 (setq qtddigitos (+ qtddigitos 1 (setq numero (atoi (substr text (+ contadortext 2 qtddigitos (if (> numero maior (setq maior numero (setq contador (+ contador 1 (setvar "luprec" Luprec (setq MaiorN (+ maior 1 (defun c:quadro( (setq PTI (getpoint "\nselecione o ponto de inserção: " (setq Luprec (getvar "luprec" (setq listss (ssget "_A" '((0. "Text" ;selectiona todos os texts do projeto (setq contador 0;contador dos texts