completo - pfc_2
DESCRIPTION
programming cTRANSCRIPT
UNIVERSIDADE FEDERAL DO CEARÁDEPARTAMENTO DE ENGENHARIA MECÂNICA E DE PRODUÇÃO
CURSO DE ENGENHARIA MECÂNICA
RAFAEL DE CARVALHO FARIAS
PROGRAMAÇÃO PARA ENGENHARIAS UTILIZANDO SOFTWARES LIVRES
FORTALEZA2008
RAFAEL DE CARVALHO FARIAS
PROGRAMAÇÃO PARA ENGENHARIAS UTILIZANDO SOFTWARES LIVRES
Monografia submetida à Coordenação do Curso de Graduação em Engenharia Mecânica, da Universidade Federal do Ceará, como requisito parcial para obtenção do grau de Graduado em Engenharia Mecânica.
Área de concentração:Universidade Federal do Ceará.
Orientador: Prof. Dr. Carlos André Dias Bezerra.
FORTALEZA2008
RAFAEL DE CARVALHO FARIAS
PROGRAMAÇÃO PARA ENGENHARIAS UTILIZANDO SOFTWARES LIVRES
Dissertação submetida à Coordenação do Curso de Graduação em Engenharia Mecânica, da Universidade Federal do Ceará, como requisito parcial para obtenção do grau de Graduado em Engenharia Mecânica.
Aprovada em _____/______/__________.
BANCA EXAMINADORA
__________________________________Prof. Dr. Carlos André Dias Bezerra (Orientador)
Universidade Federal do Ceará
__________________________________Prof. Dr. Clodoaldo de Oliveira Carvalho Filho
__________________________________Prof. Dr. Paulo Alexandre Costa Rocha
__________________________________Eng. Dr. Giovanilton Ferreira da Silva
Ao meu Pai, Francisco Helder Farias, que me ensinou: “Uma amizade verdadeira é o melhor remédio para a solidão.”.
AGRADECIMENTOS
A Deus pelas oportunidades que tem me dado na vida.
A minha família que me apoiou e me apóia nos momentos mais difíceis.
A minha amada esposa, que teve e tem paciência comigo, me dará o nosso
primeiro filho, Enzo.
Aos meus amigos que me apoiaram e incentivaram para a realização deste
trabalho.
Aos meus colegas de trabalho que sempre acreditaram em mim.
Ao Prof. Dr. Carlos André Dias Bezerra que me incentivou para a realização
deste trabalho.
A todos as outras pessoas que por falta de oportunidade não tenho uma
aproximação que gostaria de ter, mas com o pouco de contato que tive me ajudaram na
realização deste trabalho.
“Hackers são pessoas que adoram brincadeiras inteligentes.”(Richard Stallman)
RESUMO
Este trabalho incentiva o uso de softwares livres para a arte da programação computacional para Engenharias. Além de demonstrar o uso da programação como ferramenta para o exercício da profissão, este trabalho demonstra que é possível combater a pirataria com o uso de softwares livres. Algumas rotinas computacionais são apresentadas de forma bastante didática e contrárias à metodologia aplicada no ensino da programação para Engenharias, devido ao difícil acesso a um material didático voltado para a área. E os materiais didáticos voltados para as Engenharias, geralmente, são baseados em programas proprietários e de elevado custo.
Palavras-chave: Programação, educação, software livre, engenharia.
LISTA DE SÍMBOLOS
SÍMBOLOS REFERENTES AO CAPÍTULO 4:
qr = taxa de calor
k t = coeficiente de condução do tubo
k i = coeficiente de condução do isolamento
L = comprimento da tubulaçãor2 = raio externo do tubor3 = raio externo do isolamentoT i = temperatura de entrada do vapor
T ∞ = temperatura ambiente
h = coeficiente de convecçãom = vazão mássicac p = calor específico
T = queda de temperatura
SÍMBOLOS REFERENTES AO CAPÍTULO 5:
T m ,c = temperatura média do casco
T i ,c = temperatura de entrada do casco
T o ,c = temperatura de saída do casco
T m ,t = temperatura média nos tubos
T i ,t = temperatura de entrada nos tubos
T o ,t = temperatura de saída nos tubos
m = vazão mássicac p = calor específico
vc = velocidade do óleo no casco
w = vazão volumétricaAb = área da seção transversal do bocal
P = passo longitudinalDt = diâmetro dos tubos do feixe
vmax = velocidade máxima do óleo no casco
ReD , c = número de Reynolds no casco
c = densidade do óleo no casco
c = viscosidade dinâmica no casco
NuD ,c = número de Nusselt no casco
C = valor tabeladom = valor tabeladon = valor tabeladoPr = número de PrandtPr s = número de Prandt ambiente
k c = coeficiente de condução do casco
mt = vazão mássica nos tubos
c p ,t =calor específico nos tubos
= viscosidade dinâmica nos tubosN t = número de tubos do feixe
f = fator variávelNuD ,t = número de Nusselt nos tubos
ReD , t = número de Reynolds nos tubos
Pr t = número de Prandt nos tubos
h t = coeficiente de convecção nos tubos
hc = coeficiente de convecção no casco
U = coeficiente global de transferênciaq = taxa de transferência de calorR = valor tabeladoS = valor tabelado
F cr = fator de correção
Passo = passo entre tubos do feixeT lm , CF = média de temperatura logarítmica
Lt = comprimento do tubo do feixe
SÍMBOLOS REFERENTES AO CAPÍTULO 6:
M max = momento máximo
V max = força cisalhante máxima
P = forçaL = comprimento da viga
Snec = módulo de resistência da seção da vigaI = momento de inérciac = distância da linha neutra = tensão
adm = tensão admissível
mat = tensão do material
fs = fator de segurançaSnectab = módulo de resistência da seção tabelado
SÍMBOLOS REFERENTES AO CAPÍTULO 7:
e te = espessura da chapa do tampo semi-elíptico
P = pressão de trabalho internaR = raio mínimo internoS = Tensão admissível do materialE = coeficiente de eficiência da solda
PMTAte = pressão máxima de trabalho admissível do tampo semi-elíptico
e tc = espessura da chapa do tampo cônico
= ângulo do tampo cônicoPMTAtc = pressão máxima de trabalho admissível do tampo cônico
e tp = espessura da chapa do tampo plano
PMTAtp = pressão máxima de trabalho admissível do tampo plano
N = valor tabeladoPMTA = pressão máxima de trabalho admissível do costado
e = espessura da chapa do costadoes = espessura estrutural da chapa do costado
C = sobreespessura de corrosão
SUMÁRIO
1 INTRODUÇÃO.............................................................................................................111.1 Programação para Engenharias?................................................................................111.2 GPL, livre, gratuito, aberto, customização, trabalho colaborativo..........................121.3 Porque e quais softwares utilizar.................................................................................132 PREPARANDO O COMPUTADOR E ESCOLHENDO A LINGUAGEM............152.1 Configurando o compilador.........................................................................................152.2 A linguagem de programação C...................................................................................183 PRIMEIROS PASSOS PARA PROGRAMAÇÃO EM C.........................................193.1 Estrutura de um programa em “C” e o 1° programa................................................193.2 As 4 operações básicas da Matemática........................................................................233.3 Entendendo as funções trigonométricas.....................................................................264 DIMENSIONAMENTO DE ISOLAMENTO TÉRMICO
EM LINHA DE VAPOR ..............................................................................................294.1 Introdução......................................................................................................................294.2 Características do problema........................................................................................304.3 Base teórica....................................................................................................................314.4 Algoritmo do programa................................................................................................334.5 Código-fonte comentado passo a passo.......................................................................345 PROJETO DE UM TROCADOR DE CALOR DO TIPO CASCO E TUBOS
(ÁGUA – ÓLEO)...........................................................................................................425.1 Introdução......................................................................................................................425.2 Características do problema........................................................................................435.3 Base teórica....................................................................................................................455.4 Algoritmo do programa................................................................................................515.5 Código-fonte comentado passo a passo.......................................................................526 PROJETO DE VIGA BI-APOIADA...........................................................................646.1 Introdução......................................................................................................................646.2 Características do problema........................................................................................656.3 Base teórica....................................................................................................................676.4 Algoritmo do programa................................................................................................696.5 Código-fonte comentado passo a passo.......................................................................707 PROJETO DE VASOS DE PRESSÃO........................................................................777.1 Introdução......................................................................................................................777.2 Características do problema........................................................................................787.3 Base teórica....................................................................................................................797.3.a Dimensionamento do costado.........................................................................................797.3.b Dimensionamento dos tampo..........................................................................................797.4 Algoritmo do programa................................................................................................827.5 Código-fonte comentado passo a passo.......................................................................83CONCLUSÃO.........................................................................................................................90REFERÊNCIAS......................................................................................................................91APÊNDICE A – Fontes de informação para instalação do Ubuntu.................................. 92APÊNDICE B – Códigos-fonte dos programas abordados ................................................93APÊNDICE C – Ilustrações de execução dos programas abordados ..............................121
11
1 INTRODUÇÃO
1.1 Programação para Engenharias?
O ensino da programação para os cursos de Engenharia são, atualmente, falhos
em sua maioria das vezes. Em muitas Universidade como a UFC – Universidade Federal do
Ceará, as disciplinas voltadas para a área da programação se encontram com dificuldades para
serem lecionadas. As dificuldades mais insistentes são: a falta de laboratórios com uma
estrutura para tal atividade, troca constante de professores, material didático voltado para a
Engenharia e a continuidade do ensino com utilização da programação ao longo do curso.
Existem outras dificuldades, como a falta de informação sobre softwares livres
que podem ser utilizados sem infringir leis de direitos autorais e com baixo custo. A utilização
de softwares proprietário de forma ilegal no país como o sistema operacional Windows®,
ferramentas de escritório Microsoft Office®, desenhos técnicos como o AutoCAD® e até
mesmo para a programação em certas linguagens com o uso dos softwares da Borland® são
uma realidade infeliz.
Esse trabalho tem como objetivo servir de material didático, se possível, para
os estudantes de Engenharia que queiram aprender programação com exemplos práticos
utilizando softwares livres, e assim conhecer as vantagens de um trabalho colaborativo. Uma
informação que vale ser salientada nesse momento, é que todo o conteúdo deste trabalho será
disponibilizado para as pessoas que tiverem interesse em aprender um pouco de programação
e sua utilização na área de Engenharia.
O motivo da realização deste trabalho é devido à dificuldade já mencionada na
aprendizagem da programação computacional nos cursos de Engenharia na UFC, e uma forma
de contribuição e agradecimento com a comunidade acadêmica e a sociedade como um todo.
12
1.2 GPL, livre, gratuito, aberto, customização, trabalho colaborativo
O trabalho realizado utilizou um SO (Sistema Operacional) totalmente livre e
gratuito sob a licença GPL (Generic Public License), as ferramentas abordadas para o
desenvolvimento de softwares também estão sob a mesma licença. É demonstrado que,
atualmente, nós podemos utilizar os softwares livres em nossas atividades mais comuns e na
aprendizagem da programação para Engenharia. Todo este trabalho foi escrito com o uso de
softwares livres.
Vale ressaltar neste momento sobre os termos livre, aberto e grátis. O termo
livre indica que todos podem usar de forma gratuita, geralmente, mas não necessariamente. O
termo aberto indica a possibilidade de customizarmos a ferramenta que estamos utilizando. O
termo grátis é o mais claro para todos, é usado por um determinado período ou por tempo
indeterminado de acordo com a versão escolhida. Quando é mencionado os termos aberto e
livre, isso indica que estamos trabalhando com ferramentas gratuitas em sua maioria das vezes
e com a possibilidade de modificarmos e repassar as melhorias realizadas para as outras
pessoas na mesma forma.
Todas as ferramentas que serão abordadas podem ser adquiridas de forma legal
e serão usadas para beneficiar outras pessoas que poderão colaborar com esse trabalho, com o
trabalho colaborativo.
13
1.3 Porque e quais softwares utilizar
O primeiro passo, se deve com a instalação de um SO (Sistema Operacional)
livre, aberto e gratuito. Para SO, a escolha adotada é o Ubuntu na sua versão 7.10. Ele é uma
boa opção por ser Live-CD (SO que rodam diretamente do CD) que pode ser instalado no
computador ou não. O Ubuntu 7.10 além de ser bastante difundido e de fácil acesso, tem
outras vantagens como a sua facilidade de manuseio, ferramentas embarcadas, utilitários,
aplicativos e diversos outros softwares de uso comum prontos para uso.
O Ubuntu 7.10 apresenta por padrão o Open Office para escritório (editor de
texto, planilha eletrônica, banco de dados, apresentador e criador de slides e etc.), na área
multimídia como o Totem (reprodutor de áudio e vídeo), na edição de imagens com o Gimp e
diversos outros softwares. A forma de instalação de programas é extremamente fácil e
rapidamente um usuário iniciante no mundo Linux/GNU aprenderá.
O nome Linux é originado e criado por Linus Torvalds. Já a sigla GNU é
devido ao projeto GNU. O projeto GNU foi iniciado por Richard Stallman com o objetivo de
criar um sistema operacional totalmente livre. A sigla GNU foi escolhida pelo fato de ser um
acrônimo recursivo de “GNU is Not Unix” que em português significa: “GNU não é Unix”.
Quando uma distribuição se refere a Linux/GNU, na verdade ela é baseada e bem parecida
com o sistema operacional Unix, mas não é.
O Ubuntu 7.10 é uma distribuição derivada do Linux/GNU. É utilizado o Linux
como SO por ser o próprio kernel (núcleo e SO) e os softwares GNU que se integram com o
Linux, formando o Ubuntu 7.10. Veja como ocorre a integração:
Linux (kernel) + GNU (softwares) = Ubuntu 7.10
O que difere as distribuições Linux/GNU são os softwares integrados e
distribuídos com ela, pois o Linux (kernel) é o mesmo para todas elas basicamente.
Freqüentemente, o kernel sofre atualizações e por isso ele se difere muito pouco entre as
distribuições.
Agora que está explicado da forma mais básica possível sobre a escolha do SO
adequado para a realização deste projeto, é importante mencionar um pouco sobre os
programas que foram utilizados na realização deste trabalho. É interessante utilizar um editor
de texto bastante simples chamado Gedit o qual foi utilizado para a elaboração dos textos dos
programas (rotinas, funções, fórmulas, comentários e etc). O Gedit é fácil de ser utilizado e
14
lembra bastante o Bloco de Notas do SO Microsoft Windows. A diferença é que no Gedit
quando se salva o arquivo com o código fonte, ele automaticamente modifica a cor do texto
para que as funções, comentários e outros elementos do texto sejam diferenciadas.
O compilador utilizado e recomendado é o GCC. Compilador é a ferramenta
responsável para transformar o texto que foi escrito na linguagem de programação escolhida
no arquivo executável do programa desejado. O arquivo executável gerado pelo compilador é
exatamente o programa ou programas desenvolvidos. Com um editor de texto e um
compilador, todos são capazes de escrever seus próprios programas e executá-los
normalmente.
Neste trabalho não é abordada a instalação do SO Linux/GNU, mas no
Apêndice A, se encontram alguns endereços eletrônicos bastante interessantes para se iniciar
no mundo Linux/GNU. Alguns termos mais técnicos são abordados nos próximos capítulos, e
a explicação de cada termo será apresentada da forma mais detalhada possível.
É importante ressaltar uma última observação sobre software livre, o termo
livre se difere no sentido de gratuito, mas geralmente eles são gratuitos e os criadores de
programas livres ganham com o suporte para clientes que apresentem dificuldades em seu
uso. O termo gratuito não tem significado livre ou aberto, ele só se refere a utilização gratuita
de uma determinada versão ou determinado período. Já o termo aberto não se refere a livre e
nem gratuito, e sim a possibilidade de se adquirir o código-fonte do programa.
15
2 PREPARANDO O COMPUTADOR E ESCOLHENDO A LINGUAGEM
2.1 Configurando o compilador
Quando se escreve algum programa, deve-se usar com um editor de texto (no
caso o Gedit) e em seguida salvá-lo, para que ele seja transformado no programa. O programa
é exatamente o nosso código-fonte funcional. A ferramenta responsável em transformar as
ações e tarefas que se escreve no editor de texto para a forma de programa é o compilador.
O GCC (GNU Compiler Collection) é o compilador gratuito, livre e aberto que
será apresentado nesta literatura para transformar os códigos-fonte para a forma de programa.
A versão atualmente instalada pelo Ubuntu 7.10 é a 4.1.3. Ele é bem simples de ser utilizado e
atende todas as necessidades dos programas apresentados.
No menu Aplicações->Acessórios->Terminal, abrirá uma janela chamada
“TERMINAL” que se trata da linha de comando do Linux. É possível ter várias janelas de
terminal abertas, mas o limite máximo são 64 terminais aproximadamente. Para a instalação
de novos programas, o terminal ainda é a melhor solução do que as ferramentas assistidas do
Ubuntu 7.10 e outras distribuições Linux/GNU.
Durante a instalação do Ubuntu 7.10, é criada a conta de um usuário para
acessá-lo. Esse usuário que provavelmente tem o nome do criador ou seu apelido não é um
super-suário. O super-usuário é o administrador de tudo no SO, ele é responsável por todas as
configurações, instalações, remoções e outros. A senha deve ser determinada ao se iniciar a
primeira vez o SO, dessa forma é possível utilizar o “TERMINAL” para executar as tarefas de
instalação do GCC e outras que serão apresentadas neste trabalho. Para alterar a senha do
super-usuário (o nome verdadeiro é “ROOT”) basta seguir a seqüência de menu: Sistema-
>Administração->Usuários e Grupos. É necessário escolher o “ROOT” e alterar a sua senha
para se ter permissões privilegiadas quando necessárias.
Alterada a senha do “ROOT”, imprescindível a verificação da versão do GCC
instalada e isso é realizado com o comando:
gcc –version
No terminal de execução, esse comando deve se apresentar da seguinte forma:
nome@máquina:~$ gcc –version
16
No local do “nome” é o usuário ativo no exato momento, e no lugar de
“máquina” é o nome da máquina que foi definida durante a instalação do SO no computador.
No caso acima, o usuário do computador está apresentado como usuário padrão do SO. Para
executar o mesmo comando como “ROOT” se deve digitar:
nome@máquina:~$ su
Logo em seguida, será solicitada a senha do “ROOT” e a linha de comando
(linha que espera o comando do usuário ativo) se apresentará na forma:
root@máquina: /home/usuário#
Isso informa que o usuário do SO naquele momento é o “ROOT”
(administrador) e que se encontra na pasta do usuário que iniciou o SO. O “ROOT” também
tem sua pasta que se encontra na raiz do sistema de arquivos. Veja que o cifrão foi substituído
pelo #. Assim todos os comandos que serão apresentados a partir de agora e que possuem o
símbolo #, está subtendido que o usuário ativo é o “ROOT”. Quando o símbolo for o $, então
não é necessário o operador da máquina estar ativo com o usuário “ROOT”.
Para um melhor entendimento dos conceitos do Linux/GNU e a manipulação
de usuários, é necessário ler o Apêndice A que apresenta diversos endereços eletrônicos sobre
Linux/GNU.
Com a abertura do terminal como “ROOT”, é interessante a instalação do
pacote essencial do GCC para os cálculos matemáticos e programação avançada. O comando
que deve ser digitado no terminal é o:
#apt-get install build-essential
Esse comando fará com que seu computador entre em contato com os
servidores responsáveis pela atualização e instalação remota do SO, e assim, esse pacote será
instalado no computador. Provavelmente será necessário a confirmação para a instalação do
pacote e para isso basta que seja respondido “SIM”.
É importante lembrar que o computador deve estar conectado com a internet
para que a instalação do pacote seja realizada com sucesso. Se o computador não possui
disponível uma conexão com a Internet, então é necessária a instalação do pacote em questão
17
a partir dos DVDs da distribuição Debian Linux/GNU. O Ubuntu é uma distribuição baseada
no Debian, então não serão apresentados problemas de incompatibilidade. Mas essa
instalação a partir dos DVDs do Debian não será discutida neste trabalho.
18
2.2 A linguagem de programação C
É necessário mencionar sobre a necessidade da criação das linguagens de
programação e a escolha da linguagem que foi abordada ao longo deste trabalho. As
linguagens de programação surgiram para facilitar a comunicação dos softwares com os
hardwares das máquinas. Pois a linguagem de máquina se reduz a uma quantidade enorme de
0 e 1 que é chamada de linguagem binária. Essa linguagem binária é a compreendida pelos
processadores. Quando se desenvolve um programa para a soma de 2 números por exemplo,
na verdade, cada valor assumirá uma quantidade de 0 e 1 em uma determinada ordem e a
operação de soma e o resultado são apresentados da mesma forma.
Existem diversas linguagens de programação e compiladores para cada uma
delas. Algumas linguagens de programação apresentam similaridades entre si, mas todas têm
uma determinada característica na sua utilização e escolha. Existem linguagens específicas
para cálculos científicos, outras que trabalham diretamente com a Internet, com banco de
dados e etc.
A linguagem abordada neste trabalho é a “C”. Ela é uma linguagem bem
simples e de fácil entendimento. A linguagem “C” foi criada por Dennis Ritchie na AT&T
Bell Labs com o intuito de desenvolver o SO Unix para ser utilizado em servidores. A
linguagem se espalhou por outros sistemas como o Windows, Linux, Unix (atualmente
Solaris), BSD e outros. Por ser uma linguagem portável, ela pode ser utilizada em diferentes
plataformas. O “C” foi desenvolvido baseado no SO Unix por volta de 1969 e 1973, mas
aproximadamente 10 anos após a sua criação, apresentava uma certa ausência de
padronização nos compiladores. Os programas eram escritos com diversas ferramentas que
nem todos os compiladores conseguiam entender. Para solucionar essa problema, a ANSI
(Instituto Nacional Americano de Padronização), implantou uma norma para a linguagem
“C”. Assim, os compiladores desenvolvidos atualmente buscam atender todos os programas
desenvolvidos com base no padrão ANSI C.
Os programas que serão apresentados nesse trabalho podem ser compilados em
Linux/GNU, Microsoft Windows ou em qualquer outro SO, desde que o compilador atenda o
padrão ANSI C. Em muitas Empresas e Universidades o software livre não é dominante, mas
existem compiladores gratuitos de linguagem “C” para SO proprietários.
19
3 PRIMEIROS PASSOS PARA PROGRAMAÇÃO EM C
3.1 Estrutura de um programa em “C” e o 1° programa
Um programa escrito em qualquer linguagem de programação segue uma
ordem lógica na sua criação. A divisão existente nos códigos-fonte na grande maioria das
linguagens segue com o “CABEÇALHO” e “DESENVOLVIMENTO”.
O “CABEÇALHO” é composto pelas bibliotecas. As bibliotecas são arquivos
que contém as explicações e funcionalidades das funções que são empregadas no código-
fonte. A soma de 2 números, o cálculo do cosseno de um determinado ângulo, constantes
como o “л” são exemplos de elementos que não é necessária a explicação de como
funcionam. Ou seja, não se precisa criar o funcionamento de funções como as citadas, pois
elas já são descritas no padrão ANSI C.
As bibliotecas citadas, nos programas abordados neste trabalho são: stdio.h,
stdlib.h e math.h. Elas possuem um significado específico como “Standart Input/Output” para
stdio.h, “Standart Library” para stdlib.h e “Mathematic” para math.h. Elas possuem as
informações necessárias para a execução de todos os problemas abordados. A biblioteca do
padrão ANSI C possui 15 arquivos de bibliotecas, já alguns compiladores possuem bibliotecas
com funções bastantes interessantes, mas esse não é o foco deste trabalho. Um outro detalhe
interessante é que a linguagem no padrão ANSI C apresenta um vocabulário de 32 palavras-
chaves, logo, é de fácil aprendizagem.
Veja um programa bastante simples que não faz absolutamente nada:
#include <stdio.h> |#include <stdlib.h> | Parte 1#include <math.h> |
//--------------------------- | Parte 2
main () |{ |printf ("Nao faz nada!\n"); | Parte 3return 0; |} |FIGURA 3.1.1 – Simples código-fonte com divisões explicativas.
O código-fonte foi dividido em 3 partes. A primeira se refere aos arquivos de
biblioteca declarados. Quando se insere “#include” e o nome da biblioteca entre os sinais de
maior e menor, automaticamente o compilador irá pegar as funções dessas bibliotecas e
20
utilizá-las quando necessário. Mesmo que não seja utilizadas as funções ou as bibliotecas
como um todo, não representa um problema para o programa. Quando o local completo da
biblioteca não for especificado, o compilador buscará em seu diretório de bibliotecas.
A segunda parte do código-fonte se refere a forma de inclusão de comentários.
Simplesmente, todas as vezes que for digitada “//”, o restante da linha se torna um
comentário. Isso permite a inserção de comentários ao longo do programa e a facilitação para
terceiros entenderem o que foi escrito. Nos programas que serão apresentados mais adiante,
será mostrado diversos comentários ao longo do código-fonte, exatamente, para servir de
explicação do mesmo.
Na terceira parte do código-fonte é onde se escreve o programa em si. A
terceira parte apresenta todas as tarefas do programa em seqüências. A soma de 2 números, a
escrita na tela do que é digitado ou cálculos de um trocador de calor, tudo é escrito na terceira
parte.
Uma técnica recomendada para a elaboração de um bom código-fonte é a
escrita do algoritmo. Existem diversos livros que abordam o estudo de algoritmos e eles
servem como um esqueleto do código-fonte. As disciplinas de programação sempre são
iniciadas com o estudo de algoritmos, dessa forma é fácil de se visualizar o código-fonte. A
escrita do algoritmo é basicamente a descrição de forma detalhada de todos os passos de
execução do programa. Este trabalho não aborda o estudo e a criação do algoritmo, pois a
própria seqüência de resolução dos problemas abordados podem ser considerados como uma
forma de algoritmo.
Para explicação da FIGURA 3.1.1 escrito anteriormente, é necessário escrever
o código-fonte em um editor de texto puro. Para acessar o o editor de texto puro no Ubuntu
7.10, basta seguir o menu “Aplicações -> Acessórios -> Editor de texto” ou então abrir um
TERMINAL e escrever “$ gedit” e pressionar a tecla “Enter”. Após a execução de algum
desses procedimentos o editor de texto abrirá sem problemas. Agora, basta digitar o código-
fonte abaixo:
#include <stdio.h> #include <stdlib.h> #include <math.h> //----------------------------------- main () { printf ("Nao faz nada!\n"); return 0; }FIGURA 3.1.2 – Simples código-fonte sem divisões explicativas.
21
Agora é necessário que o código-fonte seja salvo com o nome
“programa-001.c” em uma pasta, ou então, que se crie uma pasta para os programas
apresentados neste trabalho, e assim, sejam localizados facilmente.
O próximo passo é a compilação e criação do arquivo executável do primeiro
programa, mas antes de prosseguir, é necessário explicar a funcionalidade do mesmo. Após a
declaração das bibliotecas (Parte 1 da FIGURA 3.1.1) e a inserção do comentário (Parte 2 da
FIGURA 3.1.1) o programa se inicia com a palavra “main”. As funções da linguagem “C”
serão explicadas mais adiante, mas para dar continuidade é necessário abordar o mínimo
possível. A palavra “main” está representando a função principal. Ela é seguida por parênteses
que representam o valor adotado e em seguida um jogo de chaves com informações. A
comparação da função “main” com uma função matemática conhecida é uma das formas de
seu entendimento. Veja:
f (x) = ax + b é equivalente a main (x) {ax + b}
A função matemática está para a função “main” da mesma forma que a
expressão de soma está para o conteúdo das chaves. Ou seja, a função “main” será executada
de acordo com o seu conteúdo. Na linguagem “C” é possível escrever diversas funções, mas o
programa sempre começará pela função “main”. O trabalho com funções será melhor
explicado em capítulos posteriores, pois será de grande valia na formação de blocos de
códigos-fonte.
Partindo para o conteúdo da função “main”, é apresentada a palavra “printf”
que também é uma função. Ou seja, uma função dentro de outra função (função composta). O
“printf” é na verdade, a função responsável para imprimir na tela do computador os
resultados, comentários, observações e etc. No primeiro programa ela simplesmente irá
apresentar a frase: “Nao faz nada!”. Uma observação importante na linguagem “C” é que não
existem caracteres com acentos, por isso o “Não” não possui acento na frase. Após qualquer
texto que for designado para ser apresentado na tela pela função “printf” e tiver em seu início
ou final o termo “\n”, será saltada uma linha.
Após a função “printf”, é apresentada a linha com o comando “return 0” que é
o responsável para a finalização do programa. E em seguida é finalizada a ação da função
“main” com o fechamento das chaves. Agora, depois de explicar o programa de forma básica
e rápida, pode ser executada a sua compilação.
Para compilar o primeiro programa, basta abrir o terminal e acessar a pasta que
22
se encontra o arquivo criado (programa-001.c). O comando de compilação com o GCC
(compilador mencionado no início deste trabalho) é bastante simples. Observe:
$ gcc programa-001.c
Será criado um arquivo executável na mesma pasta com o nome “a.out” e para
executá-lo basta digitar:
$ ./a.out
A execução do programa não passa da impressão da frase “Nao faz nada!”. Um
detalhe interessante é que o executável gerado pode ter qualquer nome, mas por padrão ele
gera como “a.out”. A criação do executável com um nome de escolha do programador, deve
executar o GCC com o parâmetro abaixo:
$ gcc programa-001.c -o nomedesejavel
Agora é possível executar o programa com o nome desejado com o mesmo
comando. Veja:
$ ./nomedesejavel
Uma última observação que deve ser comentada é o motivo do arquivo criado
no editor de texto se chamar “programa-001.c”. Na verdade o nome do arquivo pode ser
qualquer um, mas a extensão “.c” define que se trata de um código-fonte escrito na linguagem
“C”. Quando se trabalha com a linguagem “C++”, por exemplo, a extensão do arquivo se
torna “.cpp”. Seguindo essas regras, é possível compilar todos os programas apresentados
neste trabalho em qualquer compilador que segue o padrão ANSI C no SO que utilizar.
23
3.2 As 4 operações básicas da Matemática
A utilização das 4 operações básicas da Matemática é de grande importância
para o uso cotidiano. A visita ao supermercado no início ou fim do mês é um ótimo exemplo
de subtração. O 13° salário é outro bom exemplo de adição de dinheiro no orçamento familiar.
Logo, as 4 operações básicas que serão mencionadas são: soma, subtração, multiplicação e
divisão. Para se entender o conceito das operações com o uso da linguagem “C”, observe o
código-fonte abaixo:
#include <stdio.h> #include <stdlib.h> #include <math.h> //----------------------------------- main () { double x, y, z; printf ("\nVamos somar dois numeros."); printf ("\n\nDigite o valor de x:"); scanf ("%lf",&x); getchar (); printf ("Digite o valor de y:"); scanf ("%lf",&y); getchar (); z=x+y; printf ("z e igual a: %lf\n",z); getchar (); return 0; }FIGURA 3.2.1 – Código-fonte da soma de 2 números.
A “Parte 3” do código-fonte acima, é onde contém uma das 4 operações básicas
da matemática e o seu funcionamento na linguagem “C”. Primeiramente, se escreve o código-
fonte no editor de texto puro já mencionado e salva o arquivo com o nome: programa-002.c.
Assim, os programas apresentados neste trabalho serão armazenados em ordem crescente de
dificuldade.
Os números e letras do alfabeto podem ter diversos significados e para se
atribuir o valor de um número a uma letra ou palavra, se deve declará-las no código-fonte.
Veja a tabela abaixo para entender alguns padrões que a linguagem “C” utiliza:
24
TABELA 3.2.1 (página 18 – Apostila Curso de Linguagem C – UFMG)
Tipo Formato para leitura com “scanf”
Intervalo (Início) Intervalo (Fim)
char %c -128 127
unsigned char %c 0 255
signed char %c -128 127
int %i -32.768 32.767
unsigned int %u 0 65.535
signed int %i -32.768 32.767
short int %hi -32.768 32.767
unsigned short int %hu 0 65.535
signed short int %hi -32.768 32.767
long int %li -2.147.483.648 2.147.483.647
signed long int %li -2.147.483.648 2.147.483.647
unsigned long int %lu 0 4.294.967.295
float %f 3,4E-38 3,4E+38
double %lf 1,7E-308 1,7E+308
long double %Lf 3,4E-4932 3,4E+4932
Agora, basta entender cada linha do código-fonte escrito. Veja que após
declarada a função “main”, foi afirmada na declaração “double x, y, z;” que “x, y, z”
assumiram um valor numérico do tipo double. O tipo “double” informa que as variáveis
declaradas se encontram com um intervalo numérico entre 1,7E-308 e 1,7E+308, ou seja,
esses serão os valores máximo e mínimos admitidos durante os cálculos. Após a declaração de
x, y e z, basta imprimir na tela o próximo passo na execução do programa. É informado que o
usuário deve entrar com o valor de x que será somado com outro número.
Para a entrada do valor de “x”, é utilizada a função “scanf” que é a responsável
por armazenar todas as informações de entrada pelo teclado. A função “scanf” na entrada do
valor de “x”, explica que ele será um “double” e que seu valor ficará armazenado em “x”.
Veja a linha dessa função mais uma vez:
scanf (“%lf”,&x);
Veja que dentro da função “scanf” se apresentam 2 termos bastante
interessantes que devem ser explicados agora. O que se encontra dentro de aspas “%lf” se
25
refere que o termo “x” será de valor “double”, pois “lf” seria igual a “long float”. Mas o termo
“long float”é o mesmo que “double”. A linguagem “C” faz essas diferenças que serão
percebidas ao longo dos exemplos apresentados nos capítulos subseqüentes. O termo “&x”
apresentado após a vírgula, significa que o valor de “x” será digitado no teclado e que
assumirá o tipo de número designado antes da vírgula. Pode parecer um pouco complicado e
confuso, mas a linguagem “C” por incrível que pareça é a mais fácil de ser compreendida pela
maiorias das pessoas que buscam aprender um linguagem de programação.
Continuando a explicação do código-fonte, a função “getchar ()” é apresentada
logo em seguida, pois espera que o usuário pressione a tecla “Enter” do teclado para continuar
com a execução do programa. O mais importante da função “getchar ()” no momento é a
pausa que ela provoca durante a execução.
Pode se perceber que as próximas 3 linhas depois da execução da função
“getchar ()” é a repetição de entrada de um valor, mas agora do “y” que é o valor a ser
somado com o “x”. Continuando com a linha que determina o valor de “z”, que é o resultado
da operação matemática, se obtém: z = x + y. Note, que não é necessário informar o tipo de
dado do “z”, pois ele já foi declarado no início do programa.
Agora veja a forma de como é mostrado o valor de “z”, já calculado pela soma
dos valores de “x” e “y”:
printf ("z e igual a: %lf\n",z);
Simplesmente, será impresso na tela a frase “z e igual a:” com o valor de “z”
sendo do tipo “double” e chamado para a posição em que “%lf” se encontra. Após a vírgula
digitamos o termos que será chamado para a posição, e se percebe que é o valor de “z”. Um
detalhe importante são as aspas utilizadas no início e fim da frase que se deseja imprimir na
tela.
Depois de todos esses passos explicados, deve-se inserir a função “getchar ()”
mais uma vez para pausar a execução. A linha seguinte, serve para encerrar o programa
apresentado, pois a função “return 0” apresenta o significado de “exit” nessa situação. Mas ela
será melhor abordada nos exemplos dos capítulos posteriores. O “return 0” é para retornar o
valor de zero para a função “main” que logo entenderá que para o valor zero se deve encerrar
o programa.
A operação de soma apresentada pode ser substituída pelas outras 3 operações
da Matemática, bastando substituir o sinal de operação.
26
3.3 Entendendo as funções trigonométricas
O seção 3.3 trás 2 exemplos para a utilização das relações trigonométricas. O
primeiro exemplo pode ser considerado a forma mais simples de se usar funções seno,
cosseno e tangente. Já o segundo exemplo, apresenta o conceito de uma função previamente
definida e chamada quando necessária. É um pouco complicado de se entender no segundo
exemplo, mas de grande importância para a redução do número de linhas e elevar a elegância
do código-fonte escrito.
O primeiro exemplo trás o simples cálculo do seno de um número, mas a
linguagem “C” não trabalha com graus, e sim com radianos. Logo, é necessário fazer a
transformação do ângulo antes da função seno ou dentro dela. Observe o primeiro exemplo:
#include <stdio.h> #include <stdlib.h> #include <math.h> //----------------------------------- main () { double x, y;printf("\nEntre com o ângulo em graus para calcularmos o seno:");scanf("%lf",&x);getchar();y = sin((x*M_PI)/180);printf ("\nO valor do seno e: %lf\n",y);getchar();return 0; }FIGURA 3.3.1 – Código-fonte de programa para conversão de ângulos.
Note que na 11ª linha do código-fonte, está a transformação do ângulo para
radianos dentro da função seno. Essa é a forma mais simples de se entender e utilizar, mas a
quantidade de linhas e a confusão quando aplicada em uma equação mais complexa é bem
nítida, assim, ela deixa de ser interessante. A saída seria escrever uma função entre o
cabeçalho e a função “main” do código-fonte. Veja o segundo exemplo:
27
#include <stdio.h> #include <stdlib.h> #include <math.h> //------------------------------------------------------double DegToRad (double x){return (x*M_PI/180);} //------------------------------------------------------main () { double x, y;printf("\nEntre com o ângulo para calcularmos o seno:");scanf("%lf",&x);getchar();y = sin(DegToRad(x));printf ("\nO valor do seno e: %lf\n",y);getchar();return 0;}FIGURA 3.3.2 - Código-fonte de programa alternativo para conversão de ângulos.
O trecho da criação da função está na primeira caixa de texto, exatamente entre
o “CABEÇALHO” e o “DESENVOLVIMENTO”, e sua aplicação na segunda caixa de texto.
É visível a melhora na escrita, pois todas as vezes que for necessária a transformação de um
ângulo para radianos nas funções trigonométricas, basta chamar “DegToRad()”. A escolha da
expressão “DegToRad” é para ficar de fácil entendimento a frase “Degree to Radian”, que
traduzindo para a língua portuguesa, significa “Graus para Radianos”. É possível criar
funções de diversos tipos. Vale ressaltar nesse momento que esse método de criação de
funções será bastante útil na criação de códigos-fonte em blocos.
Para explicar o que ocorre com a função “DegToRad”, é importante entender a
sua estrutura no trecho na primeira caixa de texto:
double DegToRad (double x){return (x*M_PI/180);}
É declarado que a a função “DegToRad” é do tipo “double” e retornará um
valor “x” do tipo “double”. Em seu corpo, foi informado que o valor de retorno deve ser o
valor “x”, mas sendo multiplicado por “Л” e dividido por 180. Isso resulta, exatamente, na
transformação do valor de “x” em radianos. Ou seja, veja a aplicação da função:
y = sin(DegToRad(x));
O valor de x inserido na função “main” sofre a transformação para radianos
28
devido a função “DegToRad” e dessa forma, o valor do seno pode ser calculado de forma
correta. Após a escrita do programa e sua explicação de funcionamento, basta compilá-lo. A
compilação possui um detalhe quando utilizado o SO Ubuntu 7.10. Na utilização do “Л” e das
funções trigonométricas é necessária a inserção do termo “-lm” no final do comando de
compilação do GCC. Essa expressão deve ser usada para forçar o compilador a usar a
biblioteca matemática que possui as funções trigonométricas e o “Л”. Uma sugestão para o
nome dos arquivos referentes aos dois exemplos nesse capítulo são programa-003.c e
programa-004.c respectivamente. Veja como seria o comando de compilação de cada um dos
exemplos:
$ gcc programa-003.c -lm -o nomedesejavele
$ gcc programa-004.c -lm -o nomedesejavel
Após a compilação dos códigos-fonte, a execução do programa será satisfatória
e os resultados são obtidos com 6 casas decimais significativas.
29
4 DIMENSIONAMENTO DE ISOLAMENTO TÉRMICO EM LINHA DE VAPOR
4.1 Introdução
O processo de dimensionamento e escolha de um isolamento térmico em linhas
de vapor ou qualquer outra substância, deve ser realizado de forma a não apresentar uma
perda considerável de material de construção e assim reduzir os custos. É necessário abordar a
forma de como os cálculos devem ser realizados e para tal situação, é necessário o uso de
conhecimentos em transmissão de calor. A rotina computacional que é apresentada no
decorrer do capítulo poderá servir de base para resolução de situações na vida profissional de
um engenheiro.
30
4.2 Características do problema
Para iniciar a elaboração de uma rotina computacional para o dimensionamento
do isolamento em um duto, é necessário tomar como base algumas informações como: o
fluido em questão, o material da tubulação e os diversos tipos de isolantes térmicos, por
exemplo. Esse capítulo trata do desenvolvimento de tal rotina computacional para as seguintes
situações:
1. Elaborar a rotina computacional para o dimensionamento de uma linha de vapor a
partir da queda de temperatura da linha;
2. Poder inverter o procedimento e calcular a queda de temperatura de uma linha de
vapor a partir da espessura do isolamento.
O dimensionamento deve ser calculado de forma automática a partir de um
conjunto mínimo de dados de entrada e considerando que o vapor escoa em regime
estacionário e plenamente desenvolvido. Lembrando que as condições de transferência de
calor por convecção são assumidas constantes.
Os resultados que devem ser apresentados no final da execução do programa
para a situação 1 são: espessura do isolamento térmico crítica e recomendada, temperatura da
superfície externa do isolamento e peso do isolamento térmico por unidade de comprimento.
Os resultados que devem ser apresentados no final da execução do programa
para a situação 2 são: espessura do isolamento térmico crítico, queda de temperatura por
unidade de comprimento, temperatura da superfície externa do isolamento e peso do
isolamento térmico por unidade de comprimento.
Para complicar um pouco mais na elaboração do programa, é interessante a
opção de material da tubulação e do isolamento térmico empregado. O comprimento e
diâmetro da tubulação também são inseridos como dados do programa. Dessa forma, o
software pode ser elaborado de forma mais abrangente.
31
4.3 Base teórica
A rotina computacional apresenta duas possibilidades de cálculo de espessura
de isolamento e queda de temperatura na linha, veja:
1 – Determinar a espessura de um isolamento térmico a partir da queda de temperatura
da linha;
2 – Determinar a queda de temperatura a partir da espessura de um isolamento térmico.
Para as duas situações propostas é necessário o conhecimento do que ocorre na
linha de vapor. Veja a figura abaixo:
FIGURA 4.3.1 – Desenho esquemático do isolamento térmico em um trecho de tubulação.
Para calcular alguma das duas situações propostas pela rotina computacional, é
necessário considerar a condutividade térmica do tubo, do isolamento e a convecção do
isolamento térmico com o ambiente. A taxa de condução térmica em superfícies cilíndricas é
dada pela fórmula:
drdTLkqr ⋅⋅⋅⋅−= )2( π (4.3.1)
As resistências térmicas da secção circular que devem ser consideradas são:
32
FIGURA 4.3.2 – Desenho esquemático de um corte um trecho de tubulação com isolamento
térmico.
A lâmina de alumínio que, geralmente, envolve o isolamento para protegê-lo da
umidade pode ser desconsiderada, pois a espessura da lâmina é de aproximadamente 0,3 mm.
Logo, o valor da taxa de condução térmica pode ser escrita como:
321
2)2/3ln(
2)1/2ln(
rhLkLrr
kLrr
TTiq
it
r
⋅⋅⋅⋅+
⋅⋅⋅+
⋅⋅⋅
∞−=
πππ (4.3.2)
E igualando com uma outra forma de escrever a taxa de condução térmica:
Tcm
rhLkLrr
kLrr
TTip
it
∆⋅⋅=
⋅⋅⋅⋅+
⋅⋅⋅+
⋅⋅⋅
∞−
321
2)2/3ln(
2)1/2ln(
πππ (4.3.3)
Com essa equação acima, é possível determinar a queda de temperatura
isolando o “∆T” ou a espessura do isolamento térmico pela subtração da expressão
matemática “r3 – r2”. O código-fonte descrito na sessão abaixo, apresenta todo o
procedimento das equações apresentadas é possível o usuário determinar durante a execução
do programa diversas variáveis de projeto. A escolha do material do tubo, o tipo de
isolamento, vazão mássica do vapor, temperatura de entrada do vapor e outras informações
são exemplos de variáveis que podem ser inseridas.
33
4.4 Algoritmo do programa
Escolha da opção de seleção:→ espessura pela queda de temperatura→ queda de temperatura pela espessura
→ finalização
Procedimento de entrada dedados para a primeira opção
Procedimento de entrada dedados para a segunda opção
Cálculo interat ivo ut ilizando arot ina “ while”.
Dados de entrada:→ temperaturas
→ queda de temperatura→ tipo de isolamento
→ material do tubo
Dados de entrada:→ temperaturas
→ queda de temperatura→ tipo de isolamento
→ material do tubo
Finaliza / Reinicia
Impressão de resultados
Cálculo direto pelafórmula de “qr”
34
4.5 Código-fonte comentado passo a passo
O código-fonte é apresentado por partes, pois o seu conteúdo na íntegra se
encontra no Apêndice B. Serão apresentados trechos que explicam a funcionalidade do
programa, e as partes de complementação do mesmo são omitidas quando desnecessárias para
o seu entendimento.
Após o “CABEÇALHO” padrão já mencionado nos capítulos anteriores, se
deve fazer a escolha entre as duas opções de solução do programa ou a finalização do mesmo.
Um outro detalhe é a descrição do termo “inicio:”, ele é o responsável pela reinicialização do
programa. Veja:
main () { inicio: printf ("\n DIMENSIONAMENTO DE ISOLAMENTO TERMICO EM LINHA DE VAPOR"); printf ("\n\n\n 1 - Determina a espessura do isolamento a partir da queda de temperatura."); printf ("\n 2 - Determina a queda de temperatura a partir da espessura do isolamento."); printf ("\n 3 - Finalizar o programa."); printf ("\n\n\n Escolha a Situacao:");
A escolha é realizada pela adição de uma condição chamada “if”, que apresenta
o significado de “se” em português. Com os valores de 1 até 3 de acordo com as opções
mencionadas no início do programa. Observe:
int x; scanf ("%d",&x); if (x==1) {
O início da condição caso seja escolhida a primeira opção de execução do
programa, é com a declaração de variáveis da Equação 4.3.3. Note que todos os valores são
do tipo “double”, assim, é possível se trabalhar com um intervalo bastante considerável.
Perceba:
double R1, R2, R3, KI, KT, H, L, VAZAO, Cp, e, vazao, C0, C1, C2, C3, Teta, TI, TA, Tsi, RC, Funcao, T_int, T_ext, PESO, Qr, dT, Ro, G, Eiso, dTporL, L1, L2, T1, T2;
35
Após a declaração das variáveis dentro da primeira condição “if”, diversos
valores são perguntados e inseridos na memória. Dessa forma, as variáveis assumem o seu
valor ou servem de base para valores de outras variáveis. A especificação do diâmetro externo
do tubo, espessura da parede do tubo são variáveis necessárias para o cálculo da variável
responsável pelo raio interno do tubo. Veja:
printf ("\n Espeficique a diametro externo do tubo (m): "); scanf ("%lf",&R2); printf (" Especifique a espessura da parede do tubo (m): "); scanf ("%lf",&e); R1 = R2-e;
O próximo passo dentro da primeira condição é a escolha do material do tubo
que compõe a tubulação. Depois das mensagens informativas das opções dos tubos, é criada
uma seqüência de condições do tipo “if”, novamente, para a escolha da característica do
coeficiente de condutividade térmica por condução. Observe:
printf ("\n Escolha o material do tubo:\n"); printf (" 1 - Tubo de aco carbono ANSI 1010.\n"); printf (" 2 - Tubo de aco INOX ANSI 304.\n"); printf (" 3 - Tudo de bronze comercial.\n"); printf (" Escolha: "); int KTubo; scanf ("%d",&KTubo); if (KTubo == 1) {KT = 63.9;} //Tubo de aço carbono ANSI 1010. if (KTubo == 2) {KT = 14.9;} //Tubo de aço INOX ANSI 304. if (KTubo == 3) {KT = 52;} //Tubo de bronze comercial.
Agora, o mesmo procedimento para a escolha do tipo de isolamento térmico e a
adição da característica de densidade. Perceba:
printf ("\n Escolha o material do isolamento termico:\n"); printf (" 1 - Manta de la de vidro.\n"); printf (" 2 - Tubo bi-partido de la de rocha.\n"); printf (" 3 - Flocos de la de rocha.\n"); printf (" Escolha: "); int KIsolamento; scanf ("%d",&KIsolamento); if (KIsolamento == 1) {KI = 0.025; Ro = 40;}
36
if (KIsolamento == 2) {KI = 0.046; Ro = 130;} if (KIsolamento == 3) {KI = 0.037; Ro = 60;}
Logo em seguida, o valor do coeficiente de convecção externa é adotado e mais
informações são pedidas como: comprimento da tubulação, vazão mássica do vapor,
temperaturas interna e externa da tubulação. Veja:
H = 30; //Coeficiente de convecção externa. printf ("\n Informe o comprimento da tubulacao (m): "); scanf ("%lf",&L); printf (" Informe a vazao massica do vapor (kg/s): "); scanf ("%lf",&vazao); VAZAO = vazao/3600; printf (" Informe a temperatura do vapor (oC): "); scanf ("%lf",&T_int); printf (" Informe a temperatura do ambiente (oC): "); scanf ("%lf",&T_ext);
Após a entrada de todas as informações, as equações abaixo fazem outros
cálculos como a conversão da temperatura de °C para K. Vale ressaltar que o valor do vapor
não deve ultrapassar o intervalo de 250 K – 1200 K, pois os valores das constantes C0, C1, C2
e C3 para o cálculo do calor específico “Cp” estão fixados no código-fonte. Perceba que no
trecho abaixo, também é declarado o valor da gravidade para o cálculo do peso do isolamento.
Observe:
TI = T_int+273.15; TA = T_ext+273.15; Teta = TI/1000; C0 = 1.79; C1 = 0.107*Teta; C2 = 0.586*Teta*Teta; C3 = -0.2*Teta*Teta*Teta; G = 9.81; Cp = (C0+C1+C2+C3)*1000;
Abaixo, contém uma das formas de se calcular o valor do isolamento térmico a
partir da queda de temperatura na linha. O método aplicado foi a aproximação dos dois lados
da Equação 4.3.3, pois o valor do raio externo do isolamento térmico assumido, inicialmente,
é exatamente igual ao raio externo do tubo selecionado. Dessa forma, a condição “while”, que
37
possui o significado de “enquanto” em português, é aplicada para que ocorra o incremento de
0,0000001 no valor do raio externo do isolamento. Assim, ocorre um looping dentro da
condição “while” até que o valor do raio externo do isolamento permita a veracidade da
igualdade da Equação 4.3.3. Então, encontrado o valor do raio externo do isolamento, é fácil
de encontrar o valor da espessura do isolamento pela expressão “Eiso = R3-R2”. Perceba:
R3 = R2; printf (" Informe a queda de temperatura na linha (oC/m):"); scanf ("%lf",&dTporL); Funcao = ((TI-TA)/((((log(R2/R1)))/(2*M_PI*KT*L))+(((log(R3/R2)))/(2*M_PI*KI*L))+(1/(H*2*M_PI*R3*L))))/(VAZAO*Cp); while (((dTporL*L)/Funcao)<1) { R3 = R3+0.0000001;Funcao = ((TI-TA)/((((log(R2/R1)))/(2*M_PI*KT*L))+(((log(R3/R2)))/(2*M_PI*KI*L))+(1/(H*2*M_PI*R3*L))))/(VAZAO*Cp); } Eiso = R3-R2;
Após o cálculo da espessura do isolamento térmico, o programa continua a
resolver a primeira condição “if” caso tenha sido escolhida a primeira opção de solução. E o
passo seguinte, é a impressão dos resultados e o cálculo de algumas informações úteis
provenientes do processo de dimensionamento do isolamento. A temperatura externa do
isolamento, o peso do isolamento por unidade de comprimento e o raio crítico do isolamento
são exemplos de respostas que podem ser adquiridas com o programa. Veja:
printf ("\n Espessura do isolamento recomendada ========================> %5.4lf (m)", Eiso); L1 = log(R2/R1); L2 = log(R3/R2); T1 = (L1*H*R3)/KT; T2 = (L2*H*R3)/KI; Tsi = ((TI/(T1+T2))+TA)/((1/(T1+T2))+1)-273.15; printf ("\n Temperatura da superficie externa do isolamento ============> %5.2lf oC", Tsi); PESO = G*Ro*(R3*R3-R2*R2)*M_PI; RC = (KI/H); printf ("\n O peso do isolamento em kgf/m ==============================> %5.3lf N/m", PESO); printf ("\n O raio critico do isolamento ===============================> %5.5lf m", RC);
Um outro detalhe que vale ressaltar a influência do raio crítico na escolha e
utilização do isolamento térmico. Para a definição do raio crítico sendo maior ou menor que o
raio interno do tubo é inserida a condição “if” já conhecida, e em seguida a condição “else”
38
para a complementação. Após a definição do raio crítico em relação ao raio interno do tubo, a
continuação do programa segue com o comando “goto inicio;” que se trata da volta de
execução do programa para o termo “inicio:”. Veja:
if (RC<R1) { printf ("\n\n Como o raio do tubo e maior do que o raio critico, qualquer adicao de"); printf ("\n camadas de isolamento ira aumentar a resistencia total e portanto"); printf ("\n diminuindo a perda de calor."); } else { printf ("\n\n Como o raio do tubo e menor que o raio critico, a resistencia total"); printf ("\n diminui e, portanto, a taxa de calor aumenta com a adicao de camadas"); printf ("\n de isolamento."); } printf ("\n\n\n Pressione a tecla ENTER para reiniciar."); getchar(); getchar(); goto inicio; }
Agora, a resolução da segunda opção do programa é explicada. Perceba que a
segunda opção se inicia pela condição “if”. Observe:
if (x==2) {
A declaração de todas as variáveis é necessária, pois a condição “if” trata o
código-fonte com ramificações independentes. Assim, existe a necessidade de declarar tudo
novamente, mas basta copiar a declaração já realizada na condição “if” inicial. Perceba:
double R1, R2, R3, KI, KT, H, L, VAZAO, Cp, T1, T2, T_int, T_ext, C0, C1, C2, C3, Teta, TI, TA, Tsi, RC, L1, L2, e, vazao, D1, D2, PESO, Qr, dT, Ro, G, Eiso, dTporL, Q1, Q2, Q3;
Os passos seguintes são os mesmos da primeira condição já apresentada.
Perceba que nesse segundo caso, a Equação 4.3.3 precisa ter o valor da queda de temperatura
isolada para o cálculo. Cálculo é bem mais fácil do que na primeira opção. Veja:
39
printf ("\n Especifique a diametro externo do tubo (m): "); scanf ("%lf",&R2);printf (" Especifique a espessura da parede do tubo (m): "); scanf ("%lf",&e); R1 = R2-e; printf ("\n Escolha o material do tubo:\n"); printf (" 1 - Tubo de aco carbono ANSI 1010.\n"); printf (" 2 - Tubo de aco INOX ANSI 304.\n"); printf (" 3 - Tudo de bronze comercial.\n"); printf (" Escolha: "); int KTubo; scanf ("%d",&KTubo); if (KTubo == 1) {KT = 63.9;} //Tubo de aço carbono ANSI 1010. if (KTubo == 2) {KT = 14.9;} //Tubo de aço INOX ANSI 304. if (KTubo == 3) {KT = 52;} //Tubo de bronze comercial. printf ("\n Escolha o material do isolamento termico:\n"); printf (" 1 - Manta de la de vidro.\n"); printf (" 2 - Tubo bi-partido de la de rocha.\n"); printf (" 3 - Flocos de la de rocha.\n"); printf (" Escolha: "); int KIsolamento; scanf ("%d",&KIsolamento); if (KIsolamento == 1) {KI = 0.025; Ro = 40;} if (KIsolamento == 2) {KI = 0.046; Ro = 130;} if (KIsolamento == 3) {KI = 0.037; Ro = 60;} H = 30; printf ("\n Informe o comprimento da tubulacao (m): "); scanf ("%lf",&L); printf (" Informe a vazao massica do vapor (kg/s): "); scanf ("%lf",&vazao); VAZAO = vazao/3600; printf (" Informe a temperatura do vapor (oC): "); scanf ("%lf",&T_int); printf (" Informe a temperatura do ambiente (oC): "); scanf ("%lf",&T_ext); TI = T_int+273.15; TA = T_ext+273.15; Teta = TI/1000; C0 = 1.79; C1 = 0.107*Teta; C2 = 0.586*Teta*Teta; C3 = -0.2*Teta*Teta*Teta; G = 9.81; Cp = (C0+C1+C2+C3)*1000;
Agora, basta entrar com o valor da espessura do isolamento para a execução
restante do programa elaborado. Perceba que são recalculados todos os itens da primeira
condição, novamente, mas com o valor da espessura do isolamento designada pelo o usuário.
40
Observe:
printf (" Espessura do isolamento desejado (m):"); scanf ("%lf",&Eiso); R3 = R2+Eiso; L1 = log(R2/R1); L2 = log(R3/R2); D1 = 2*M_PI*KT*L; D2 = 2*M_PI*KI*L; Q1 = L1/D1; Q2 = L2/D2; Q3 = 1/(2*M_PI*R3*H*L); Qr = (TI-TA)/(Q1+Q2+Q3); dT = (Qr)/(VAZAO*Cp); dTporL = dT/L; T1 = (L1*H*R3)/KT; T2 = (L2*H*R3)/KI; Tsi = ((TI/(T1+T2))+TA)/((1/(T1+T2))+1)-273.15; PESO = G*Ro*(R3*R3-R2*R2)*M_PI; RC = (KI/H); printf ("\n A queda de temperatura na linha por unidade de comprimento => %5.9lf oC/m", dTporL); printf ("\n Temperatura da superficie externa do isolamento ============> %5.2lf oC", Tsi); printf ("\n O peso do isolamento em kgf/m ==============================> %5.3lf N/m", PESO); printf ("\n O raio critico do isolamento ===============================> %5.5lf m", RC);
A definição do raio crítico encontrado é mais uma vez apresentada e a
reinicialização do programa é executada para se escolher, novamente, as opções ou a
finalização do programa. Note:
if (RC<R1) { printf ("\n\n Como o raio do tubo e maior do que o raio critico, qualquer adicao de"); printf ("\n camadas de isolamento ira aumentar a resistencia total e portanto"); printf ("\n diminuindo a perda de calor."); } else { printf ("\n\n Como o raio do tubo e menor que o raio critico, a resistencia total"); printf ("\n diminui e, portanto, a taxa de calor aumenta com a adicao de camadas"); printf ("\n de isolamento."); } printf ("\n\n\n Pressione a tecla ENTER para reiniciar."); getchar(); getchar(); goto inicio; }
41
A última condição “if” que se refere às opções iniciais de apresentação do
programa, é responsável somente para a finalização do mesmo. Perceba que o termo “return
0” é utilizado para tal situação. Veja:
if (x==3) { return 0; } getchar(); return 0; }
As possibilidades para alteração e melhorias do programa apresentado nesse
capítulo são inúmeras. O programa pode sofrer o acréscimo de materiais para isolamento
térmico, tubos de outros materiais para a linha de vapor, o acréscimo de novos fluidos e etc,
são algumas opções de melhorias e expansões que podem ser citadas.
42
5 PROJETO DE UM TROCADOR DE CALOR DO TIPOCASCO E TUBOS (ÁGUA – ÓLEO)
5.1 Introdução
O projeto de trocadores de calor é de grande valia para a profissionais na área
de engenharia, seja um Engenheiro Mecânico ou Engenheiro Químico. Os trocadores de calor
são utilizados em sua grande maioria nas indústrias químicas para resfriar ou aquecer uma
determinada substância. Um exemplo bem típico e fácil de demonstrar é a utilização desse
equipamento para o aquecimento de água na entrada de uma caldeira, assim, a água entra pré-
aquecida não afetando de forma brusca o fornecimento de vapor da caldeira. Esse capítulo
demonstra a elaboração de uma rotina computacional para o projeto de um trocador de calor
do tipo casco e tubo.
FIGURA 5.1.1 – Vista de corte de um trocador de calor do tipo casco-tubo.
Para se ter um problema palpável é necessário escolher líquidos com suas
propriedades em tabelas conhecidas. Para exemplificar a rotina computacional deste capítulo,
as substâncias escolhidas são: água e óleo de motor. Sendo o óleo como o fluido de maior
temperatura e que será resfriado pela perda de calor.
43
5.2 Características do problema
O problema comumente encontrado para o projeto de um trocador de calor é a
ausência de alguns dados iniciais. As possibilidades de configuração de um trocador de calor
casco-tubo são inimagináveis para um mesmo problema. A experiência e a prática constante
no projeto e dimensionamento de trocadores de calor leva o projetista a uma proximidade da
melhor relação entre custo e benefício.
Um ótimo problema para a elaboração de uma rotina computacional é de um
trocador de calor do tipo casco-tubo para arrefecimento e sem mudança de fase. Fluidos como
a água, que é utilizada para o resfriamento de um óleo de motor utilizado na lubrificação de
um compressor é bastante comum. A rotina computacional deste capítulo trás a resolução
desse problema. Os dados do óleo de motor a ser considerado são:
● A temperatura de entrada no trocador é de 95 °C e sua saída com 60 °C com uma
vazão de 75 litros por minuto;
● O óleo de motor passa pelo casco, pois geralmente é recomendado que o fluido quente
passe por entre o feixe de tubos;
● Considerações adicionais como: diâmetro do bocal de entrada e saída do óleo, adição
de chicanas, opções de intervalos de temperatura e outras informações, são à cargo do
projetista.
Os dados da água para resfriamento do óleo deve ter as seguintes
características:
● Entrada a temperatura ambiente;
● Ela passa pelo feixe de tubos fazendo com que ocorra a troca térmica com o óleo;
● O diâmetro dos tubos para a passagem da água é de definição do projetista;
● O material dos tubos é considerado pelo projetista;
● Outras considerações ficam a cargo do projetista.
Para a elaboração mais facilitada da rotina computacional, pode se admitir que
o diâmetro do casco pode ser escolhido entre 3” e 12” e seu comprimento ente 350 mm e
3050 mm. O material do casco, tampos, bocais e outros acessórios fica a cargo do projetista.
Com alguns dos parâmetros já descritos, fica mais fácil de se elaborar a rotina
44
computacional. É interessante que o programa forneça dados auxiliares como: área de troca
térmica, coeficiente global de transferência de calor, excesso do trocador e outros. No
próximo item “5.3 – Base teórica.” há uma das formas de se realizar um programa para o
projeto do trocador de calor.
45
5.3 Base teórica
Antes de prosseguir com a elaboração da rotina computacional, é preciso
compreender a seqüência de resolução. Primeiramente, é necessário fazer algumas
considerações como:
● O óleo passa do lado do casco e a água por dentro dos tubos do feixe;
● A água e o óleo apresentam suas correntes em sentidos contrários devido a maior troca
térmica;
● O escoamento dos fluidos se encontra plenamente desenvolvido;
● Perda de calor para a vizinhança, variações de energia cinética e potencial
desprezadas;
● Resistência térmica da parede dos tubos do feixe são desprezíveis, pois deve-se
considerar um tubo delgado;
● Regime estacionário;
● Não ocorre geração de trabalho;
● Perda de carga é desprezível.
Um detalhe importante para a ser mencionado é que a rotina abaixo é elaborada
para o cálculo do comprimento do casco do trocador de calor. Dessa forma, o usuário do
programa entrará com os dados dos líquidos e fará algumas escolhas sobre a dimensão do
trocador de calor. O resultados que serão apresentados servirão para uma análise crítica que
visa a viabilidade do projeto.
São utilizadas para os cálculos as tabelas com as propriedades da água e do
óleo de motor, encontradas em diversos livros de transmissão de calor, pois será necessário a
interpolação de diversos valores. Para se iniciar o procedimento de cálculo é necessário o
cálculo das temperaturas médias da água e do óleo. Veja as equações:
T m ,c=T i , cT o , c
2(5.3.1)
e
T m ,t=T i ,tT o , t
2(5.3.2)
46
A Equação 5.3.1 representa a temperatura média da água que será aquecida e a
Equação 5.3.2 representa a temperatura média do óleo que será resfriado. Assim a troca
térmica ocorrerá no sentido óleo->água, ou seja, o calor será retirado do óleo e absorvido pela
água.
Para dar início a resolução do problema, é necessário escolher a substância na
qual irá ser calculada primeiramente. É apresentada a partir de agora a metodologia do óleo
que passa pelo casco do trocador de calor.
O calor extraído é calculado pela equação:
q=m⋅c p⋅T i , c−T o ,c (5.3.3)
Onde o primeiro termo é a quantidade de calor extraída em KJ/s, o segundo
trata-se da vazão mássica em kg/s, o terceiro é o calor específico em KJ/kg.K, e o quarto
termo representa a diferença de temperatura da substância. Note que a diferença de
temperatura é exatamente o valor de entrada, subtraído do valor de saída da substância em
questão. Fazendo o cálculo para o óleo que entra no casco do trocador de calor, se obtém o
valor do calor extraído em KJ/s que será utilizado mais adiante.
O próximo passo é o cálculo da velocidade do óleo no casco. Veja:
vc=wAb
(5.3.4)
O primeiro termo da equação é a velocidade do óleo no casco em m/s, o
terceiro termo que é a vazão volumétrica em m³/s que está se comportando como numerador
e o quarto termo se trata área da seção transversal do bocal de entrada do óleo em m².
Após o cálculo da velocidade do óleo no casco, é necessário o cálculo da
velocidade máxima do óleo no casco para se prosseguir com o desenvolvimento. Veja:
vmax=P
P−Dt⋅vc (5.3.5)
O primeiro termo representa a velocidade máxima que o óleo atingirá em m/s.
O termo representado pela letra “P” se refere ao passo longitudinal do feixe e tubos do
trocador de calor. Segundo a normal TEMA (Tube Exchange Materials Association) um valor
47
que se pode adotar para um passo longitudinal do tubos utilizados no feixe do trocador no
intervalo de 3/8” até 5/8” é 3/4”. Esse valor de 3/4” representa a distância entre centros dos
tubos do feixe tubular do trocador de calor. Lembrando que o arranjo considerado para os
cálculos é do tipo quadrangular.
O termo que subtrai o passo longitudinal é o próprio diâmetro dos tubos
utilizados no feixe tubular do trocador de calor. Por fim, o termo final é a velocidade do óleo
já calculada e mencionada anteriormente. Uma observação que se deve fazer agora, é sobre a
unidade adotada no passo e no diâmetro do tubo do feixe tubular, todas elas são em metros.
Com os dados calculados até o momento, se pode calcular o valor do número
de Reynolds no casco pela equação:
R eD ,c=c⋅vmax⋅D t
c (5.3.6)
Lembrando que a metodologia de cálculo apresentado é para a criação de um
trocador de calor no intervalo dado inicialmente.
O termo que multiplica a velocidade máxima e o diâmetro externo dos tubos
que compõe o feixe tubular do trocador de calor é a densidade específica do fluido em kg/m³,
e o denominador da equação é a viscosidade dinâmica em N.s/m². Lembrando que o número
de Reynolds é adimensional.
O próximo passo é o cálculo do número de Nusselt, mas para isso se deve
conhecer a fórmula. Veja:
NuD, c=C⋅R eDm⋅Pr n⋅ Pr
Pr s 0,25
(5.3.7)
Veja que os termos “m” e “n” são encontrados a partir do valor do número de
Raynolds calculado anteriormente. Veja a tabela:
TABELA 5.3.1 – (Transmissão de Calor e de Massa – Incropera e DeWitt)ReD m n
1 – 100 0,40 0,36100 – 1000 0,50 0,36103 – 2x105 0,63 0,36
2x105 – 2x106 0,80 0,40
48
O termo “C” apresentado na Equação 5.3.7 deve ser escolhido de acordo com a
tabela abaixo:
TABELA 5.3.2 – (Transferência de Calor e de Massa – Incropera e DeWitt)Nf 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15C 0,7 0,8 0,86 0,9 0,93 0,95 0,96 0,96 0,98 0,98 0,98 0,98 0,99 0,99 0,99
Todas as tabelas apresentadas até o momento se referem a resolução do
problema proposto no início do capítulo. Para outras situações é necessário toda uma
mudança no método de cálculo aplicado, tal mudança pode ser aplicada como expansão do
programa.
Após o calculo do número de Nusselt, é possível determinar o valor do
coeficiente de convecção dentro do trocador de calor pelo casco. Veja:
hc=NuD⋅k c
Dt (5.3.8)
Encontrado o valor do coeficiente de convecção do casco, o próximo passo é
encontrar o coeficiente de convecção dos tubos, pois o coeficiente de transferência global é
calculado a partir dos dois valores. Para dar continuidade é necessário calcularmos certos
valores e o primeiro deles é o fluxo mássico nos tubos do feixe. Perceba:
m=q
c p ,t⋅T o−T it (5.3.9)
Vale ressaltar que o valor de “q” já foi calculado anteriormente para o casco e
esse é o mesmo aplicado para o feixe de tubos. O valor do calor específico para o fluido dos
tubos é adquirido da mesma forma que o fluido do casco, através de tabelas e por interpolação
quando necessária e apresentado nas mesmas unidades já mencionadas. O termo “(To – Ti)t” é
exatamente a diferença de temperatura de entrada e saída do fluido que desejamos.
Agora é necessário o cálculo do número de Reynolds pela equação abaixo.
Veja:
R eD ,t=4⋅mt
N t⋅⋅Dt⋅ (5.3.10)
49
Os termos que ainda não foram mencionados são “Nt” que representa o número
de tubos do feixe, e o “µ” que é tabelado de acordo com o fluido e, geralmente, encontrado
nas unidades N.s/m². Agora com o valor do número de Reynolds, é necessário calcular o
número de Nusselt pela fórmula abaixo. Observe:
NuD ,t= f
8 ⋅R eD ,t−1000⋅Pr t
112,7⋅ f8
1 /2
⋅Pr t2 /3−1
(5.3.11)
Sendo o valor de “f” calculado pela fórmula:
f =0,790⋅ln R eD ,t−1,64 −2 (5.3.12)
O valor de “Pr” é o número de Prandtl do fluido e que pode ser obtido por
tabelas de propriedades do fluido através de interpolação simples. Após os cálculos
realizados, é possível realizar o cálculo do coeficiente de convecção dos tubos através da
equação abaixo:
h t=NuD ,t⋅k t
Dt (5.3.13)
Agora é possível se calcular o coeficiente global de transferência de calor que
servirá para o cálculo do comprimento feixe de tubos. Veja a fórmula abaixo do coeficiente
global:
U= 1hc
1h t
−1
(5.3.14)
Os cálculos a partir de agora, são visados para encontrar o valor do
comprimento do feixe tubular que pode ser considerado como o próprio comprimento do
trocador de calor. A partir do valor do comprimento do feixe, uma análise pode ser realizada
para admissão ou recusa do trocador de calor calculado pelo programa. Veja o procedimento
do cálculo do comprimento do feixe de tubos:
50
L t=q
Passo⋅N t⋅U⋅⋅Dt⋅F cr⋅T lm ,CF (5.3.15)
Onde o “Fcr” é calculado pela equação:
F cr=R210,5⋅ln 1−S⋅R
1−S
1−R⋅ln 2−S ⋅R1−R210,52−S ⋅R1R210,5
(5.3.16)
E os valores de R e S podem ser encontrados por:
S=T o, t−T i ,tT i ,c−T i ,t
(5.3.17)
e
R=T i , c−T o ,c T o , t−T i ,t
(5.3.18)
Agora, falta apenas encontrar o valor da temperatura logarítmica pela equação:
T lm , CF=T i ,c−T o ,t−T o , c−T i , t
ln T i , c−T o ,t T o , c−T i ,t (5.3.19)
Com as equações acima é possível se encontrar o comprimento do feixe
tubular, dessa forma basta realizar uma análise dos resultado. Abaixo, segue o código-fonte do
programa para o cálculo do comprimento do feixe tubular.
51
5.4 Algoritmo do programa
Início com entradade dados das substâncias
Definições e escolhasda configuração dotrocador de calor
Cálculo interno paraimpressão de
resultados
Impressão na telade resultados
Finalização
52
5.5 Código-fonte comentado passo a passo
O código-fonte abaixo se apresenta de forma resumida, pois muitos detalhes de
repetição foram substituídos por linhas pontilhadas. Dessa forma, o código-fonte para
entendimento não fica comprometido e nem extenso demais.
O código-fonte se encontra, totalmente, comentado como os apresentados até o
momento. O “CABEÇALHO” do programa é o mesmo já apresentado nos capítulos
anteriores, logo não será mostrado novamente. Assim:
main () { //Declaração de algumas constantes e variáveis. int x, y, w; double TempHE, dHE, cpHE, uHE, vHE, kHE, aHE, PrHE, TempHM, PI, TempHEntrada, TempHSaida, TempHS, dHS, cpHS, uHS, vHS, kHS, aHS, PrHS, mH, U, dTempC, mc, RedTubo, f, factor001, factor002, NudTubo, ht, R, S, F, factor003, factor004, factor005, factor006, factor007, L, DeltaTempLM, Atroca, DcascoIN, Razao, VolH2O, NudCasco, hc, mh, q, Dtubo, Dcasco, N, dTempH, Bocal, P, Nf, C, Passo, m, n, Abocal, Q, V, Vmax, RedCasco, vHM, kHM, aHM, PrHM, dHM, cpHM, uHM, TempCE, TempCS, TempCM, dCE, cpCE, uCE, kCE, PrCE, dCS, cpCS, uCS, kCS, PrCS, TempCEntrada, TempCSaida, dCM, cpCM, uCM, kCM, PrCM, Acalculada, Excesso;
Após a declaração de todas as variáveis do programa, é interessante fazer uma
figura representativa de um trocador de calor. Na execução do programa a imagem fica bem
definida. Veja como pode ser escrita a figura através de caracteres:
//Mensagem de informação do programa. printf ("\n\n SOFTWARE PARA DIMENSIONAMENTO DE"); printf ("\n TROCADOR DE CALOR DO TIPO CASCO E TUBO"); printf ("\n\n ===== \n"); printf (" | | \n"); printf (" |---|----------------------|---| \n"); printf (" | ||====================|| | \n"); printf (" || | ||====================|| | ||\n"); printf (" ||--- ||====================|| ---||\n"); printf (" ||--- ||====================|| ---||\n"); printf (" || | ||====================|| | ||\n"); printf (" | ||====================|| | \n"); printf (" |---|----------------------|---| \n"); printf (" | | \n"); printf (" ===== \n");
É interessante orientar e dar algumas informações do programa para o usuário.
53
Assim, o usuário não terá problemas com os dados de entrada referentes as temperaturas e o
intervalo no qual o programa é capaz de calcular. É importante nesse momento, informar
sobre o sentido das correntes de entrada e saída dos fluidos também. Veja:
//Entrada dos valores da temperatura de entrada e saída do óleo. printf ("\n OBSERVACOES:"); printf ("\n 1 - A temperatura do oleo deve estar na faixa de (-0.15 <-> 156.85) oC,"); printf ("\n pois corresponde a tabela encotrada em literatura."); printf ("\n 2 - A temperatura da agua deve estar na faixa de (0 <-> 91.85) oC,"); printf ("\n pois corresponde a tabela encotrada em literatura."); printf ("\n 3 - A agua entra pelo feixe de tubos e o oleo pelo casco, isso se deve,"); printf ("\n a literatura recomenda que o fluido quente passe pelo casco."); printf ("\n 4 - O trocador e do tipo 'contra corrente' pois trocadores desse tipo,"); printf ("\n apresentam melhor troca termica.");
A partir de agora, a entrada de informações e escolhas para o projeto do
trocador de calor se inicia. Perceba como o código-fonte foi escrito para pedir as temperaturas
de entrada e saída do óleo de motor:
printf ("\n\n Entre com o valor da temperatura de entrada (quente) do oleo (oC): "); scanf ("%lf",&TempHEntrada); getchar (); printf (" Entre com o valor da temperatura de saida (fria) do oleo (oC): "); scanf ("%lf",&TempHSaida); getchar ();
Após a declaração das temperaturas de entrada e saída do óleo de motor, é
necessário que o programa faça o cálculo da temperatura média e em seguida utilize a
temperatura média para uma interpolação. Essa interpolação é realizada a partir da função de
condição “if” que a linguagem “C” possui. Veja o trecho do código fonte abaixo, o “if” tem o
significado de “se”. Ou seja, se a temperatura média calculada atender ao “se”, os valores de
dentro dos colchetes serão assumidos para as variáveis apresentadas. Na última linha, dentro
do colchete de cada condição é apresentado o comando “goto”. Esse comando representa que
após assumir os valores das as variáveis dentro do colchete, as condições seguintes são
desconsideradas até encontrar no código-fonte a linha com a palavra “fimTempHE:”. A caixa
54
de diálogo abaixo apresenta algumas linhas pontilhadas, é uma forma de fazer referência a
continuidade dos “if” para outros intervalos. Não é interessante demostrar todos os “if” para
todas as temperaturas, mas o código-fonte completo é apresentado no Apêndice B. Observe:
//Busca de TempHM pelos valores menores e maiores. TempHM = (TempHEntrada+TempHSaida)/2;
//1a. parte da interpolação. if (TempHM<=-0.15) {TempHE = -0.15; dHE = 889.1; cpHE = 1796; uHE = 3.85; vHE = 0.004280; kHE = 0.147; aHE = 0.0000000910; PrHE = 47000; goto fimTempHE;} if (TempHM<=6.85) {TempHE = 6.85; dHE = 895.3; cpHE = 1827; uHE = 2.17; vHE = 0.002430; kHE = 0.144; aHE = 0.0000000880; PrHE = 27500; goto fimTempHE;} ..................................if (TempHM<=156.85) {TempHE = 156.85; dHE = 806.5; cpHE = 2471; uHE = 0.00470; vHE = 0.00000583; kHE = 0.132; aHE = 0.0000000662; PrHE = 88;} fimTempHE:
As variáveis encontradas acima são referentes ao menor ou igual valor da
temperatura listada em uma tabela em relação à temperatura média. Explicando de forma mais
clara, é encontrado o menor valor anterior a temperatura média e assim admitidos os valores
dessas variáveis. Dessa forma, a propriedades podem ter o valor menor ou igual do que o da
temperatura média armazenados na memória. O trecho abaixo faz o mesmo método do
apresentado acima, mas para encontrar os valores referentes à temperatura maior ou igual à
temperatura média. Todo esse sistema é uma forma de busca na tabela por valores anteriores e
55
posteriores das propriedades para o cálculo por interpolação simples das mesmas propriedades
para temperatura média.
//Continuação da 2a. parte para interpolação. if (TempHM>=156.85) {TempHS = 156.85; dHS = 806.5; cpHS = 2471; uHS = 0.00470; vHS = 0.00000583; kHS = 0.132; aHS = 0.0000000662; PrHS = 88; goto fimTempHS;} if (TempHM>=146.85) {TempHS = 146.85; dHS = 812.1; cpHS = 2427; uHS = 0.00564; vHS = 0.00000694; kHS = 0.133; aHS = 0.0000000675; PrHS = 103; goto fimTempHS;} ..................................if (TempHM>=-0.15) {TempHS = -0.15; dHS = 889.1; cpHS = 1796; uHS = 3.85; vHS = 0.004280; kHS = 0.147; aHS = 0.0000000910; PrHS = 47000;} fimTempHS:
Agora, com os valores anteriores e posteriores das propriedades referentes a
temperatura média. É possível o cálculo por interpolação simples para se encontrar os valores
das propriedades da temperatura média. Note o trecho do código-fonte abaixo:
//Cálculos de interpolações. vHM = (((TempHM-TempHE)*(vHS-vHE))/(TempHS-TempHE))+vHE; kHM = (((TempHM-TempHE)*(kHS-kHE))/(TempHS-TempHE))+kHE; aHM = (((TempHM-TempHE)*(aHS-aHE))/(TempHS-TempHE))+aHE; PrHM = (((TempHM-TempHE)*(PrHS-PrHE))/(TempHS-TempHE))+PrHE; dHM = (((TempHM-TempHE)*(dHS-dHE))/(TempHS-TempHE))+dHE; cpHM = (((TempHM-TempHE)*(cpHS-cpHE))/(TempHS-TempHE))+cpHE; uHM = (((TempHM-TempHE)*(uHS-uHE))/(TempHS-TempHE))+uHE;
56
Nesse momento, é possível fazer alguns cálculos para o óleo motor. Antes, é
necessária a entrada da vazão de entrada do óleo. Observe:
//Entrada do valor da vazão do óleo. printf ("\n Entre com a vazao do oleo (L/min): "); scanf ("%lf",&mH); getchar ();
Agora, a definição do passo entre os tubos do feixe é dada pelo valor de “P” no
trecho do código-fonte abaixo. O valor de 0,01905 metros é uma ótima consideração, pois tal
admissão foi realizada devido ao intervalo dos diâmetros dos tubos do feixe sugeridos no
problema enunciado no início deste capítulo. A transformação da vazão também é necessária e
pela seqüência o cálculo da diferença de temperatura e da quantidade de calor por segundo.
//Cálculos a partir da vazão do óleo fornecida. P = 0.01905; mh = (mH/60)*(dHM/1000); dTempH = TempHEntrada-TempHSaida; q = mh*cpHM*dTempH;
A escolha do diâmetro dos tubos do feixe tubular é necessária nesse exato
momento e é realizada por mais uma condição. Veja:
//Escolha do diâmetro do tubo. printf ("\n Escolha o diametro do tubo do feixe: "); printf ("\n 1 - Tubo de 3/8 in."); printf ("\n 2 - Tubo de 1/2 in."); printf ("\n 3 - Tubo de 5/8 in."); printf ("\n A escolha e: "); scanf ("%d",&x); getchar (); if (x==1) {Dtubo = 0.009525;} if (x==2) {Dtubo = 0.0127;} if (x==3) {Dtubo = 0.015875;}
Agora são listadas todas as possibilidades de configuração do trocador de calor
de acordo com os dados e parâmetros fornecidos pelo problema. Assim, após uma escolha
aleatória os resultados que serão obtidos e apresentados pelo programa podem ser analisados
57
de forma mais coerente. O usuário escolherá uma das possibilidades de configuração para os
intervalos dados no problema inicial. Veja:
//Escolha a configuração do trocador nos parâmetros abaixo. printf ("\n Escolha a configuracao do trocador de calor: "); printf ("\n 1 - 12 tubos, 1 passo, 3 in de casco"); printf ("\n 2 - 16 tubos, 1 passo, 3.5 in de casco"); printf ("\n 3 - 16 tubos, 1 passo, 4 in de casco"); ..................................printf ("\n 22 - 22 tubos, 4 passos, 8 in de casco"); printf ("\n 23 - 37 tubos, 4 passos, 10 in de casco"); printf ("\n 24 - 52 tubos, 4 passos, 12 in de casco"); printf ("\n A escolha e: "); scanf ("%d",&y); getchar (); if (y==1) {N = 12; Dcasco = 3*0.0254; Nf = 4; C = 0.90; Passo = 1;} if (y==2) {N = 16; Dcasco = 3.5*0.0254; Nf = 4; C = 0.90; Passo = 1;} ..................................if (y==24) {N = 52; Dcasco = 12*0.0254; Nf = 14; C = 0.99; Passo = 4;}
Vale salientar que a variável “C” apresentada no trecho acima do código-fonte,
é a mesma apresentada na Tabela 5.3.2 deste capítulo. O seu valor depende do número de
fileiras que também foi escolhido com base no intervalo do diâmetros do tubos do feixe e a
quantidade de tubos.
Para o prosseguimento dos cálculos, é necessária a escolha do bocal de entrada
do óleo térmico. Dessa forma, é possível o cálculo da área de entrada do bocal e assim a
velocidade e outras variáveis necessárias. Veja que o procedimento segue o mesmo princípio
já apresentado com o “if”:
58
//Escolha o bocal de entrada do óleo. printf ("\n Escolha o diametro do tubo do bocal de entrada do oleo:"); printf ("\n 1 - Bocal de 1 in"); printf ("\n 2 - Bocal de 1.5 in"); printf ("\n 3 - Bocal de 2 in"); printf ("\n A escolha e: "); scanf ("%d",&w); if (w==1) {Bocal = 0.0254;} if (w==2) {Bocal = 0.0381;} if (w==3) {Bocal = 0.0508;}
Com os dados já calculados, é possível dar continuidade no procedimento de
resolução do problema. Veja alguns cálculos complementares:
//Calculos complementares como: No. de Reynolds, área da secção do bocal e etc. Abocal = M_PI*(Bocal/2)*(Bocal/2); Q = (mH*0.001)/60; V = Q/Abocal; Vmax = (P*V)/(P-Dtubo); RedCasco = (dHM*Vmax*Dtubo)/uHM; if (RedCasco<=100) {m = 0.4; n = 0.36;} else if (RedCasco<=1000) {m = 0.5; n = 0.36;} else if (RedCasco<=200000) {m = 0.63; n = 0.36;} else if(RedCasco<=2000000) {m = 0.8; n = 0.4;}
Perceba que a partir do cálculo do número de Reynolds foi determinado os
valores de “m” e “n” da Equação 5.3.7.
Agora, o procedimento realizado com o óleo de motor para o cálculo das
propriedades do fluido é repetido para a água. O valor da temperatura de entrada e saída da
água são inseridos. Efetua-se o cálculo da temperatura média da água e em seguida o mesmo
processo de busca dos valores anteriores e posteriores e o cálculo por interpolação é realizado.
Dessa forma, é encontrado os valores das propriedades da água na temperatura média. Assim:
59
//Dados de temperatura da água de entrada e saída desejadas. printf ("\n Entre com o valor da temperatura de entrada (fria) da agua (oC): "); scanf ("%lf",&TempCEntrada); getchar (); printf (" Entre com o valor da temperatura de saida (quente) da agua (oC): "); scanf ("%lf",&TempCSaida); getchar ();
//Busca de TempCM pelos valores menores e maiores. TempCM = (TempCEntrada+TempCSaida)/2;
//1a. parte da interpolação. if (TempCM<=0) {TempCE = 0; dCE = 1; cpCE = 4217; uCE = 0.001750; kCE = 0.569; PrCE = 12.99; goto fimTempCE;} if (TempCM<=1.85) {TempCE = 1.85; dCE = 1; cpCE = 4211; uCE = 0.001652; kCE = 0.574; PrCE = 12.22; goto fimTempCE;} ..................................if (TempCM<=91.85) {TempCE = 91.85; dCE = 1.038; cpCE = 4209; uCE = 0.000306; kCE = 0.677; PrCE = 1.91; goto fimTempCE;} fimTempCE: //Continuação da 2a. parte para interpolação. if (TempCM>=91.85) {TempCS = 91.85; dCS = 1.038; cpCS = 4209; uCS = 0.000306; kCS = 0.677; PrCS = 1.91; goto fimTempCS;} if (TempCM>=86.85) {TempCS = 86.85; dCS = 1.034; cpCS = 4203;
60
uCS = 0.000324; kCS = 0.674; PrCS = 2.02; goto fimTempCS;} ..................................if (TempCM>=0) {TempCS = 0; dCS = 1; cpCS = 4217; uCS = 0.001750; kCS = 0.569; PrCS = 12.99;} fimTempCS: //Cálculos de interpolações. dCM = (((TempCM-TempCE)*(dCS-dCE))/(TempCS-TempCE))+dCE; cpCM = (((TempCM-TempCE)*(cpCS-cpCE))/(TempCS-TempCE))+cpCE; uCM = (((TempCM-TempCE)*(uCS-uCE))/(TempCS-TempCE))+uCE; kCM = (((TempCM-TempCE)*(kCS-kCE))/(TempCS-TempCE))+kCE; PrCM = (((TempCM-TempCE)*(PrCS-PrCE))/(TempCS-TempCE))+PrCE;
O cálculo de mais algumas variáveis é necessário. No trecho abaixo o cálculo
da diferença de temperatura da água, vazão mássica, número de Reynolds da água dentro dos
tubos do feixe e o cálculo de “f” que foi apresentado na Equação 5.3.12. Em seguida, é
calculado a variável “factor001” e “factor002” que são termos utilizados no cálculo do
número de Nusselt para a água no feixe tubular. Observe:
//Continuação de alguns cálculos. dTempC = TempCSaida-TempCEntrada; mc = q/(cpCM*dTempC); RedTubo = (4*mc)/(N*M_PI*Dtubo*uCM); f = 1/(((0.790*log(RedTubo))-1.64)*((0.790*log(RedTubo))-1.64)); factor001 = (f/8)*(RedTubo-1000)*PrCM; factor002 = 1+12.7*pow(f/8,0.5)*(pow(PrCM,0.666666666667)-1);
Antes de prosseguir, é necessário falar sobre a função “pow” no trecho acima.
Essa função é responsável pelas operações que envolvem potência. A função “pow” é
utilizada da seguinte forma:
pow (x,y) é o mesmo que xy
A partir de todos os cálculos dados é possível determinar o número de
61
Reynolds e o número de Nusselt da água que escoa pelos tubos. Dessa forma, é encontrado o
valor de “ht” da Equação 5.3.8. Veja:
//Cálculo para o No. de Nussent (tubo) a partir da faixa do No. de Reynolds. if (RedTubo>=2500) {NudTubo = factor001/factor002;} else {NudTubo = 4.36;} ht = (kCM*NudTubo)/Dtubo;
Agora, pode ser calculado também o “hc” da Equação 5.3.13. Isso se deve pelo
cálculo do número de Nusselt do casco. Assim:
//Cálculo do No. de Nussent (casco). NudCasco = C*(pow(RedCasco,m))*(pow(PrHM,n))*(pow((PrHM/PrCM),0.25)); hc = (kHM*NudCasco)/Dtubo;
Depois do cálculo do “hc” e “ht”, é possível encontrar o valor do coeficiente
global de transferência de calor. Observe:
//Agora temos o hc e o ht, logo calcularemos o U. U = 1/((1/ht)+(1/hc));
Veja o cálculo do fator de correção apresentado na Equação 5.3.16 e o cálculo
de “R” e “S” das Equações 5.3.17 e 5.3.18:
//Vamos calcular o fator de correção F. R = (TempHEntrada-TempHSaida)/(TempCSaida-TempCEntrada); S = (TempCSaida-TempCEntrada)/(TempHEntrada-TempCEntrada); factor005 = pow(((R*R)+1),0.5); factor003 = (2-(S*(1+R-factor005))); factor004 = (2-(S*(1+R+factor005))); factor006 = log((1-(S*R))/(1-S)); factor007 = (1-R); F = ((factor005*factor006)/(factor007*log(factor003/factor004)));
A separação da Equação 5.3.16 em termos como “factor003”, “factor004”,
“factor005”, “factor006” e “factor007” foi para facilitar a sua escrita no código-fonte.
62
Depois de cumprir o procedimento de cálculo mencionado, resta o cálculo da
diferença de temperatura logarítmica e do comprimento do casco do trocador de calor.
Observe:
//E agora calculando o valor de L que representará o comprimento do casco. DeltaTempLM = ((TempHEntrada-TempCSaida)-(TempHSaida-TempCEntrada))/ log((TempHEntrada-TempCSaida)/(TempHSaida-TempCEntrada)); L = (q/(U*M_PI*Dtubo*DeltaTempLM*F*N*Passo));
Para encerrar a parte de cálculo, o último trecho do código-fonte se trata de
cálculos informativos para a impressão na tela em forma de relatório de resultados,
juntamente, com outros dados já encontrados. Dessa forma, uma análise do trocador de calor
poderá ser realizada, e assim, decidir o cálculo de um novo trocador ou a seleção de outra
configuração. Veja os últimos cálculos:
//Cálculo de dados como: área de troca térmica, diâmentro do casco e outros.Atroca = L*N*Passo*(M_PI*2*(Dtubo/2)); DcascoIN = Dcasco/0.0254; Razao = Atroca/(M_PI*(Dcasco/2)*(Dcasco/2)); VolH2O = (mc)/(dCM*1000); Acalculada = (q/(U*DeltaTempLM)); Excesso = ((Atroca-Acalculada)/Atroca);
Agora, a impressão na tela dos resultados com o a condição “if” aplicada para
informar se os escoamentos nos tubos ou no casco é laminar ou turbulento. Nas últimas linhas
do código-fonte, é apresentada uma forma de finalização do programa:
//Resultados. printf ("\n\n----------------------------------------------------------------------------------"); printf ("\n CARACATERISTICAS BASICAS DO TROCADOR DE CALOR"); printf ("\n 1. Comprimento do Casco = %lf m",L); printf ("\n 2. Diametro do casco = %lf in",DcascoIN); printf ("\n 3. Diametro do tubo do feixe = %lf m",Dtubo); printf ("\n 4. Quantidade de tubos = %lf ",N); printf ("\n 5. Numero de passes = %lf",Passo); printf ("\n 6. Area de troca termica (calculada) = %lf m2",Acalculada); printf ("\n 7. Area de troca termica (fisica) = %lf m2",Atroca);
63
printf ("\n 8. Excesso do trocador de calor = %lf %%",Excesso); printf ("\n 9. Razao da area de troca termica (fisica) e o volume do trocador = %lf",Razao); printf ("\n 10. Coeficiente global de transferencia de calor = %lf W/m2*K",U); printf ("\n 11. Arranjo dos tubos = Quadrangular"); printf ("\n----------------------------------------------------------------------------------"); printf ("\n RESULTADOS DO OLEO (CASCO)"); printf ("\n 1. Temperatura de entrada = %lf oC",TempHEntrada); printf ("\n 2. Temperatura de saida = %lf oC",TempHSaida); printf ("\n 3. Vazao massica = %lf kg/s",mh); printf ("\n 4. Velocidade do oleo no casco = %lf m/s",V); printf ("\n 5. Velocidade maxima do oleo no casco = %lf m/s",Vmax); printf ("\n 6. Taxa de calor extraido do oleo = %lf KJ/segundo",q); printf ("\n 7. Numero de Reynolds no casco = %lf",RedCasco); printf ("\n 8. Numero de Nussent no casco = %lf",NudCasco); printf ("\n 9. Coeficiente de conveccao no casco = %lf W/m2*K",hc); if (RedCasco>2500) {printf ("\n O escoamento do oleo no casco e: Turbulento");} else {printf ("\n O escoamento do oleo no casco e: Laminar");} printf ("\n----------------------------------------------------------------------------------"); printf ("\n RESULTADOS DA AGUA (TUBOS)"); printf ("\n 1. Temperatura de entrada = %lf oC",TempCEntrada); printf ("\n 2. Temperatura de saida = %lf oC",TempCSaida); printf ("\n 3. Vazao massica = %lf kg/s",mc); printf ("\n 4. Vazao volumetrica da agua = %lf m3/segundo",VolH2O); printf ("\n 5. Numero de Reynolds nos tubos = %lf",RedTubo); printf ("\n 6. Numero de Nussent nos tubos = %lf",NudTubo); printf ("\n 7. Coeficiente de conceccao nos tubos = %lf W/m2*K",ht); if (RedTubo>2500) {printf ("\n O escoamento da agua nos tubos e: Turbulento");} else {printf ("\n O escoamento da agua nos tubos e: Laminar");} printf ("\n----------------------------------------------------------------------------------\n\n"); printf ("\n Pressione 'Enter' para finalizar."); getchar (); return 0; }
Uma última informação importante que deve ser repassada nesse momento, é
em relação a linha do relatório impresso na tela sobre o excesso do trocador de calor. O
excesso é referente a relação entre a área de troca térmica calculada e a área de troca térmica
física. O programa se encontra com décimos de excesso, ou seja, o dimensionamento do
trocador é praticamente exato ao necessário.
64
6 PROJETO DE VIGA BI-APOIADA
6.1 Introdução
As vigas são elementos estruturais bastante usados na construção civil, na área
de edificação e em estruturas metálicas. O método de cálculo para se projetar o perfil correto
de uma viga tem o grau de complexidade proporcional à forma da estrutura metálica ou
edificação. Um método de se iniciar a escolha do material da viga e dimensionamento do
perfil pode ser realizado pela análise do maior esforço no maior vão livre.
O método comentado no parágrafo acima é uma forma de iniciar o cálculo com
base em um referencial. As vigas podem ter diversos tipos de perfis, mas existem alguns que
são bastantes comerciais como o perfil C (também conhecido como U no Brasil) e o perfil I.
Os materiais empregados vão desda de aços-liga, aço carbono, aço inox, ligas de alumínio e
etc. É fácil de perceber toda a gama das variáveis presentes no projeto de uma viga.
65
6.2 Características do problema
O projeto de uma viga a ser adicionada em uma estrutura, a seleção de um
perfil correto para a construção ou a escolha do material adequado e que suporte os esforços
são exemplos de variáveis do problema.
A elaboração da rotina computacional deste capítulo foi realizada seguindo
alguns passos, como a entrada de algumas variáveis. A força aplicada sobre a viga, o
comprimento total da viga, o coeficiente de segurança que deve ser aplicado, são alguns dos
dados de entrada necessários que o usuário deve informar ao programa.
A situação considerada é referente a uma força central a uma viga na qual está
apoiada em suas extremidades. Para uma melhor compreensão veja a figura abaixo:
FIGURA 6.2.1 – Carregamento central em viga biapoiada.
Um software para o cálculo de uma viga simples como a apresentada na Figura
6.2.1 pode ter diversas variáveis como a escolha do perfil. É interessante que se possa ter uma
escolha de pelo menos dois perfis para cálculo. A força “P” aplicada no centro da viga pode
ser de qualquer valor definido pelo projetista por exemplo. Dados de entrada e saída são
extremamente importantes no final da execução do programa, assim, o projetista pode ter uma
visão crítica dos resultados, bem como se a viga irá falhar ou não.
Um aspecto interessante que se deve ter como opção na execução do programa
é informar qual o coeficiente de segurança que se deseja usar para os cálculos e uma lista de
opções de materiais como:
66
● Aço carbono A-36;
● Aço inox AISI 304;
● Liga de alumínio 2024 T4;
● e outras.
A escolha das dimensões dos perfis também fica por conta do projetista, logo a
mesma forma que é abordada em relação às opções de materiais, pode ser aplicada para as
dimensões dos perfis. No próximo item é abordada a solução teórica para a construção do
software deste capítulo.
67
6.3 Base teórica
A resolução para o problema proposto e em seguida a realização de uma rotina
computacional se inicia pela determinação do momento máximo e força cisalhante máxima.
Veja:
M max=P⋅L
4 (6.3.1)
e
V max=P2 (6.3.2)
A unidade adotada para a força “P” é o Newton e a unidade de comprimento
metro para “L” nas Equações 6.3.1 e 6.3.2. É perceptível que a unidade do momento fletor
máximo é N.m e para a força cisalhante é o Newton.
Após o cálculo do momento fletor máximo, o próximo passo é a determinação
do Snec. Snec é o módulo resistente da viga. O módulo de resistencia é a relação entre “I” e
“c”, isto é:
Snec= Ic (6.3.3)
O “I” é conhecido como momento de inércia do perfil da viga e o “c” como a
distância do eixo neutro até extremidade máxima. Utilizando a fórmula da tensão:
=M⋅c
I (6.3.4)
Agora, realizando as devidas substituições se obtém:
Snec= M adm
(6.3.5)
Como o fator de segurança é a relação da tensão de escoamento do material e a
tensão admissível, se obtém:
68
fs=mat
adm (6.3.6)
Logo, o valor de “Snec” do perfil selecionado deve ser de acordo com a
equação:
Snec= M⋅fsmat
(6.3.7)
A Equação 6.3.7 fornece o valor do módulo de resistência da viga de acordo
com o material escolhido. Lembrando que o valor da tensão admissível do material é
encontrada em tabelas de livros e apostilas.
Após o cálculo do “Snec”, é de fácil compreensão que seu valor deve ser
tomado como base na escolha do perfil de aplicação. O perfil a ser escolhido em tabelas de
perfis de diversos fabricantes deve ter o “Snec” superior ao calculado. Caso contrário, a viga
não atenderá às necessidades do projeto. Observe:
Snec tabSnec (6.3.8)
Com as equações estabelecidas, pode ser iniciado o processo de elaboração do
código-fonte.
69
6.4 Algoritmo do programa
Inicia programa
Entrada de dados
Escolhas relacionadasao perfil a ser ut ilzado
Cálculo e impressão deresultados na tela
Finalização
70
6.5 Código-fonte comentado passo à passo
O código-fonte abaixo se apresenta de forma resumida, pois muitos detalhes de
repetição foram substituídos por linhas pontilhadas. Dessa forma, para entendimento não fica
comprometido e nem extenso demais. O código pode ser visto sem cortes no Apêndice B.
main () { //Programa para projetode vigas biapoiadas.
int pI, m_viga, pC;
double P, L, CS, Mmax, Vmax, E, Ty, Tadm, Snec, Stab;
int x = 1;
printf ("\n PROGRAMA PARA O PROJETO DE VIGA BI-APOIADAS "); printf ("\n"); printf ("\n"); printf ("\n | carga P"); printf ("\n |"); printf ("\n V"); printf ("\n ====================="); printf ("\n ^ | ^"); printf ("\n |---L/2---|---L/2---|"); printf ("\n\n"); printf ("================================================================");
No trecho de código-fonte apresentado acima, é mostrada a declaração de
algumas variáveis do tipo “double” e “int”. Lembrando que o tipo “int” se refere a números
inteiros no intervalo apresentado na Tabela 3.2.1. Em seguida, é apresentada uma figura para
demonstrar o tipo de carregamento empregado sobre a viga a ser projetada.
O próximo trecho apresenta a primeira aparição neste trabalho de uma rotina de
seleção. A rotina de seleção é utilizada da seguinte forma:
71
switch ( ) {case 1: bloco de comandos; break; case n + 1: bloco de comandos; break; ............. ........ ..... case n: bloco de comandos; break;
Para o valor de( ) {se for 1: executa essa seqüência de comandos; saída da rotina de seleção; se for n + 1: executa essa seqüência de comandos; saída da rotina de seleção; ............. ........ ..... se for n: execute essa seqüência de comandos; saída da rotina de seleção;
FIGURA 6.4.1 – Estrutura das rotina com switch-case-break.
A apresentação da forma que se deve utilizar a rotina de seleção que envolve
“switch-case-break” é utilizada no programa deste capítulo e se prolongará nos próximos
programas abordados.
switch (x) { case 1: //Primeira situacao. printf ("\n Informe o valor da carga 'P' (N):"); scanf ("%lf",&P); printf ("\n Informe o comprimento da viga (m):"); scanf ("%lf",&L); printf ("\n Informe o coeficiente de seguranca:"); scanf ("%lf",&CS); //Calculos do momento maximo e da forca cortante. Mmax = P*L/4; Vmax = P/2; //Escolha do material com switch dentro de outro switch. int material_1; printf ("\n Escolha o material:"); printf ("\n"); printf ("\n [1] - A-36 [8] - AISI 304"); printf ("\n [2] - AISI-C 1018 [9] - Liga de Aluminio 1100-H12"); printf ("\n [3] - AISI-C 1030 [10] - Liga de Aluminio 2024 T4"); printf ("\n [4] - AISI-C 1040 [11] - Liga de Aluminio 6061 T6"); printf ("\n [5] - AISI-C 1080 [12] - Liga de Aluminio 6063 T6"); printf ("\n [6] - AISI-C 3140 [13] - Liga de Aluminio 2024 T4");
72
printf ("\n [7] - AISI-C 4340"); printf ("\n Sua opcao e:"); scanf ("%d",&material_1); getchar ();
O primeiro “switch” apresentado no programa ocorreu no trecho acima. Esse
“switch” é usado como uma opção para futuras situações de cálculo. É visível a sua
praticidade com a rotina, e uma nova rotina para outra situação pode ser facilmente
implementada. Uma árvore explicativa de todo o código-fonte é apresentada no final deste
item 6.4.
A ação inicial do “switch” apresentado acima é referente à execução do bloco
de comandos que pede ao usuário o valor da força “P” aplicada na viga, o valor de “L” que é
o comprimento da viga e o valor do fator de segurança. Efetua-se o cálculo internamente do
momento fletor máximo e da força cortante máxima e em seguida é realizada a escolha do
material da viga.
Uma outra característica apresentada no programa deste capítulo é a
possibilidade de rotinas aninhadas. O segmento abaixo mostra um “switch” inserido em outro
“switch” já apresentado no trecho acima, que usa o valor da opção do material da viga. Veja:
switch (material_1) { case 1: // A-36 E = 200e9; Ty = 250e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 2: // AISI-C 1018 E = 200e9; Ty = 370e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; .......................... ................ ........ ... case 13: // Liga de Aluminio 2024 T4 E = 72e9; Ty = 500e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; }
73
O bloco de código-fonte apresentado acima, é referente à escolha do material.
Outra rotina bastante similar é a aplicada nos Capítulos 5 e 6 com o uso das rotinas “if” e “if-
else-if”. A vantagem da rotina com o “switch-case-break” é mais direta. Quando o valor da
escolha é inserido no “switch” o “case” imediatamente executa o bloco de comandos de sua
responsabilidade. As variáveis são: “E” como o módulo de elasticidade do material, “Ty”
como sendo a tensão admissível do material de compressão, “Tamd” sendo a tensão
admissível calculada para o fator de segurança adotado e “Snec” como o módulo de
resistência da viga requerido.
Após recarregar os valores das variáveis na memória, o procedimento pode ser
seguido. É apresentada a aplicação de outro “switch” dentro do primeiro apresentado no início
do código-fonte. Vale ressaltar que ao final dos comentários do código-fonte terá a estrutura
do programa de forma simplificada. O bloco de código-fonte seguinte é relacionado à opção
de seleção do perfil da viga. Um outro detalhe que pode ser percebido é a inserção de outro
“switch” no “switch” de escolha do perfil da viga que se encontra dentro do “switch” do tipo
de cálculo a ser realizado. Ou seja, temos três estruturas de “switch” aninhadas. Veja:
//Escolha do perfil da viga. printf ("\n Escolha o perfil para a viga:"); printf ("\n\n [1] - Perfil I"); printf ("\n [2] - Perfil C"); printf ("\n Sua opcao e:"); int perfil; scanf ("%d",&perfil); getchar (); switch (perfil) {case 1: //Procedimento do cálculo com o perfil I pra situacao 1. printf ("\n Escolha o perfil I de acordo com as dimensoes abaixo:");
printf ("\n Lembrando que Altura x Base e a nomeclatura adotada.");
printf ("\n\n [1] - 150x14 [6] - 250x18 [11] - 310x74");
printf ("\n [2] - 150x30 [7] - 250x45 [12] - 310x129");
printf ("\n [3] - 200x22 [8] - 250x80"); printf ("\n [4] - 200x71 [9] - 250x149"); printf ("\n [5] - 200x100 [10] - 310x39");
........................ ................ .........
printf ("\n A sua escolha e:"); scanf ("%d",&pI); getchar (); switch (pI) {case 1: Stab = 91.2; break;
74
case 2: Stab = 218; break; .................... ............. ....... case 12: Stab = 1940; break;}
//-----Resultados----- printf ("\n============================================================="); printf ("\n SOLICITACAO E ESPECIFICACAO DA VIGA"); printf ("\n============================================================="); printf ("\n Carga aplicada 'P': %lf N",P); printf ("\n Comprimento da Viga: %lf m",L); printf ("\n Coeficiente de seguranca: %lf",CS); printf ("\n============================================================="); printf ("\n RESULTADOS DOS CALCULOS DA RESPECTIVA VIGA"); printf ("\n============================================================="); printf ("\n Esforco cortane maximo: %lf N",Vmax); printf ("\n Momento fletor maximo: %lf N.m",Mmax); printf ("\n Tensao admissivel: %lf Pa",Tadm); printf ("\n Tensao de escoamento: %lf Pa",Ty); printf ("\n Modulo de elasticidade do material: %lf Pa",E); printf ("\n Modulo de resistencia necessario: %lf mm3",Snec); printf ("\n Modulo de resistencia tabelado: %lf mm3",Stab); printf ("\n"); if (Snec<Stab) {printf ("\n O perfil selecionado suportara o carregamento."); printf ("\n Teste outros perfis para tentar reduzir seus gastos!");} else {printf ("\n O perfil selecionado nao duporta o carregamento."); printf ("\n Escolhe um perfil mais robusto com o Snec superio"); printf ("\n ao desejado.");} getchar (); break; case 2: //Procedimento do cálculo com o perfil C pra situacao 1. printf ("\n Escolha o perfil C de acordo com as dimensoes abaixo:"); printf ("\n Lembrando que Altura x Base e a nomeclatura adotada."); printf ("\n\n [1] - 75x6 [6] - 230x30"); printf ("\n [2] - 100x11 [7] - 250x45"); printf ("\n [3] - 150x19 [8] - 310x45"); printf ("\n [4] - 180x22 [9] - 380x50"); printf ("\n [5] - 200x28 [10] - 380x74"); ........................ ................ ......... printf ("\n A sua escola e:"); scanf ("%d",&pC); getchar (); switch (pC)
{case 1:
75
Stab = 18.1; break; case 2: Stab = 37.5; break; .................... ............. ....... case 10: Stab = 882; break;}
//-----Resultados----- printf ("\n============================================================="); printf ("\n SOLICITACAO E ESPECIFICACAO DA VIGA"); printf ("\n============================================================="); printf ("\n Carga aplicada 'P': %lf N",P); printf ("\n Comprimento da Viga: %lf m",L); printf ("\n Coeficiente de seguranca: %lf",CS); printf ("\n============================================================="); printf ("\n RESULTADOS DOS CALCULOS DA RESPECTIVA VIGA"); printf ("\n============================================================="); printf ("\n Esforco cortane maximo: %lf N",Vmax); printf ("\n Momento fletor maximo: %lf N.m",Mmax); printf ("\n Tensao admissivel: %lf Pa",Tadm); printf ("\n Tensao de escoamento: %lf Pa",Ty); printf ("\n Modulo de resistencia necessario: %lf mm3",Snec); printf ("\n Modulo de resistencia tabelado: %lf mm3",Stab); printf ("\n"); if (Snec<Stab) {printf ("\n O perfil selecionado suportara o carregamento."); printf ("\n Teste outros perfis para tentar reduzir seus gastos!"); printf ("\n");} else {printf ("\n O perfil selecionado nao duporta o carregamento."); printf ("\n Escolhe um perfil mais robusto com o Snec superio"); printf ("\n ao desejado.");
printf ("\n");} break;} break; }
getchar (); return 0; }
Para uma maior compreensão do código-fonte como um todo, é necessário ver
a descrição do mesmo de acordo com a estrutura a seguir. Observe:
76
main ( ){ switch ( ) //Escolha para possível expansão para outros tipos de carregamento. {case....... switch ( ) //Escolha do material do carregamento 1. {case ....... break ;} switch ( ) //Escolha do perfil do carregamento 1. {case ....... switch ( ) //Processo de calculo e relatório para o Perfil I. {case....... break ;} switch ( ) //Processo de calculo e relatório para o Perfil C. {case....... break ;} break ;} break ;}getchar ( ) ;return 0 ;}
FIGURA 6.4.1 – Estrutura do código-fonte aplicado no Cap. 6
Com estrutura descrita acima, é fácil perceber o início da divisão do código-
fonte em blocos. No bloco referente ao material da viga, ele poderá ser utilizado por todos os
perfis adicionados no programa para o material determinado. Dessa forma, a repetição do
código-fonte faz com que seja reduzido o tempo de escrita e otimiza a compilação do mesmo.
O último “switch” que se refere à geração de relatório para cada perfil
escolhido, também apresenta uma praticidade para possíveis expansões do programa. É
perceptível que esse programa tem como estrutura fundamental a utilização adequada da
rotina de escolha “switch-case-break”. No final de todas as rotinas de escolha, o programa é
finalizado com um simples “return 0 ;”.
77
7 PROJETO DE VASOS DE PRESSÃO
7.1 Introdução
Vaso de pressão é o termo designado para se fazer referência a todos os
recipientes estanques que apresentam pressão externa ou interna. Alguns de vasos de pressão
são: tanques de armazenamento de líquidos e grãos, uma simples panela de pressão ou até
mesmo um reator nuclear.
Na indústria química os vasos de pressão são utilizados constantemente. Seja
para o simples armazenamento de líquidos sob pressão ou em pressão atmosférica, como na
armazenagem de gases pressurizados. A importância no cálculo dos vasos de pressão são de
extrema importância, pois caso ocorra um erro de projeto, a explosão, vazamento ou
rachaduras podem comprometer a todas as pessoas que o manuseiam.
Neste capítulo, é realizado o processo de desenvolvimento de um software que
faz o dimensionamento do casco e tampos de um vaso de pressão com o sentido da pressão de
dentro para fora, ou seja, pressão interna. Existem diversos fatores e variáveis a serem
considerados como a qualidade da solda, material dos tampos, material do costado, processo
de soldagem e outros.
78
7.2 Características do problema
O projeto de um vaso de pressão é realizado a partir da entrada de alguns dados
fornecidos pelo setor de Engenharia Química de Processo de uma indústria química por
exemplo. Os Engenheiros de Processo fornecem os dados como pressão e fluido de trabalho.
A partir deste momento é necessário seguir algumas normas como a ASME - American
Society of Mechanical Engineer. A ASME apresenta procedimentos que serviram de base para
outras normas como a ABNT, por exemplo.
O procedimento de projeto para um vaso de pressão se inicia com a
determinação e entrada de alguns dados para o cálculo do casco como: raio interno do casco,
pressão de projeto, sobreespessura de corrosão quando aplicada, temperatura de trabalho e a
classe do material do casco. A partir desses dados, já é possível a determinação da tensão
admissível de cada material “S” por tabelas encontradas em livros e na própria norma ASME,
Seção VIII, Divisão 1 – UCS-23, por exemplo.
Valores de coeficientes de solda também são apresentados na norma ASME, e
variam de acordo com o grau de inspeção e tipo de solda realizada. Após as informações
fornecidas até o momento é fácil a realização do cálculo da espessura da chapa que deve ser
utilizada para o casco e os tampos de um vaso de pressão.
É muito vantajoso que seja elaborada uma rotina computacional com o intuito
da não repetição do cálculo e busca em tabelas nas normas mencionadas. Dessa forma, o
trabalho além de ser otimizado é interessante à elaboração de resultados em forma de relatório
por exemplo. No próximo item, 7.3, o procedimento teórico, como fórmulas utilizadas pela
norma ASME são mencionados, e assim no item 7.4 a descrição da rotina computacional
desenvolvida é comentada.
79
7.3 Base teórica
7.3.a Dimensionamento do Costado
A metodologia de cálculo para o dimensionamento do costado de um vaso de
pressão é a mesma adotada na ASME. A norma ASME sugere que o dimensionamento da
espessura do costado siga a equação abaixo:
e= P⋅RS⋅E−0,6⋅P
C (7.3.1)
Onde as variáveis “P” dotada é a pressão interna de projeto, “R” o raio mínimo
interno do costado, “S” a tensão admissível básica do material, “E” o coeficiente de eficiência
da solda, “C”sobreespessura de corrosão “e” a espessura mínima para a chapa do costado.
A sobreespessura de corrosão “C” é de acordo com o fluido de trabalho e o
tempo de vida do equipamento. A espessura da chapa de fabricação do equipamento não pode
ser menor que a espessura mínima de resistência estrutural. E caso isso ocorra, se deve usar a
equação da espessura mínima de resistência estrutural. Observe:
es=2,50,002⋅RC (7.3.2)
Outra informação de extrema importância é a pressão máxima de trabalho
admissível conhecida como PMTA. Ela é calculada pela equação:
PMTA= S⋅E⋅eR0,6⋅e (7.3.3)
7.3.b Dimensionamento dos tampos
O procedimento de cálculo para os tampos é similar ao cálculo do costado.
Devido a diversidade de tampos o código-fonte apresenta 3 possibilidades de escolha. Tampo
plano, semi-elíptico e cônico, são os modelos que podem ser escolhidos e para cada tipo de
tampo existe uma equação para o cálculo da espessura. Veja a equação do cálculo da
espessura para o tampo semi-elíptico e a equação para a pressão máxima de trabalho
80
admissível:
e te=P⋅R
S⋅E−0,1⋅P C (7.3.4)
e
PMTAte=S⋅E⋅ete
R0,1⋅ete (7.3.5)
Veja a forma de um tampo semi-elíptico:
FIGURA 7.3.1 – Tampo semi-elíptico.
As equações para o tampo cônico são:
e tc=P⋅R
cos ⋅S⋅E−0,6⋅PC (7.3.6)
e
PMTAtc=S⋅E⋅etc⋅cos
R0,6⋅e tc⋅cos C (7.3.7)
Onde o termo “α” representa o ângulo do teto do tampo com a linhas de centro.
Observe a forma de um tampo cônico:
FIGURA 7.3.2 – Tampo cônico.
As equações para o tampo plano são:
81
e tp= N⋅PS⋅E
C (7.3.8)
e
PMTAtp=127⋅S2⋅R (7.3.9)
Observe a forma de um tampo plano:
FIGURA 7.3.3 – Tampo plano.
82
7.4 Algoritmo do programa
Início
Escolha do materialdo vaso de pressão
Grau de inspeçãode soldagem
T ipo de solda
Escolha do tampo
Impressão de resultadosna tela
Finalização
83
7.5 Código-fonte comentado passo a passo
O código-fonte abaixo se apresenta de forma resumida, pois muitos detalhes de
repetição foram substituídos por linhas pontilhadas. Dessa forma, o código-fonte para
entendimento não fica comprometido e nem extenso demais.
O código-fonte do programa deste capítulo é bastante rico em informações,
pois ele apresenta diversos trechos em sua rotina, do conteúdo já discutido até o momento.
Rotinas de escolha como “switch-case-break”, “if-else-if”, criação de funções e outras
bastante interessantes. O cabeçalho padrão foi retirado, pois o código-fonte completo e sem
cortes se encontra no Apêndice B.
double DegToRad (double x){return (x*M_PI/180);}//---------------------------------------------------main (){double R, P, C, Temp, S, E, e, es, PMTA, e_Torri, e_Torri_PMTA, alpha, e_Cone, e_Cone_PMTA, e_Reto, e_Reto_PMTA;
int MC, Grau, Tipo, Tampo;
O bloco de código-fonte acima apresenta como início do programa a criação da
função “DegToRad” já apresentada como transformação de ângulos para radianos, pois as
linguagens de programação não trabalham de forma direta com ângulos. Após a declaração da
função é realizada a declaração de todas as variáveis utilizadas no programa. São declarados
dois tipos de variáveis, as do tipo “int” que possui as características de ser aplicada a somente
números inteiros e as do tipo “double”, já mencionada no trabalho.
printf ("\n PROGRAMA PARA O");printf ("\n DIMENSIONAMENTO DE VASOS DE PRESSAO");printf ("\n");printf ("\n Programa para dimensionamento de vasos de pressao");printf ("\n com costado cilindrico e tampos retos, conicos ou");printf ("\n torrisfericos e pressao externa.");printf ("\n\n");printf ("\n 1o. passo - Dimensionamento do costado.");printf ("\n --> Determinacao da espessura da chapa.");printf ("\n\n Entre com o raio interno do cilindro (mm):");scanf ("%lf",&R);getchar ();printf ("\n Entre com a pressao interna de projeto (Pa):");scanf ("%lf",&P);
84
getchar ();printf ("\n Entre com sobreespessura para corrosao (mm):");scanf ("%lf",&C);getchar ();
O trecho de código-fonte apresentado acima, apenas se refere à inserção de
alguns dados de entrada, como a pressão interna de projeto, raio interno do casco e a
sobreespessura para corrosão.
Temperatura:
printf ("\n Entre com a temperatura de trabalho entre -30 e 500 (oC):");scanf ("%lf",&Temp);getchar ();
A inserção da temperatura de trabalho do vaso de pressão deve ser entre -30 °C
e 500 °C. A linha que está declarada a operação “Temperatura:” servirá como local de
reinicialização para o usuário digitar, novamente, a temperatura de trabalho caso tenha sido
digitada fora do intervalo.
Classe:
printf ("\n Escolha a classe do material:");printf ("\n");printf ("\n [1] - (A-285-C)----------->Aco carbono");printf ("\n [2] - (A-387-11 c 11)----->Aco-liga 1.1/4 Cr -1/2 Mo");printf ("\n [3] - (A-387-5 c 11)------>Aco-liga 5 Cr - 1/2 Mo");printf ("\n A escolha e:");scanf ("%d",&MC);getchar ();if (MC>=4) {printf ("\n Escolha a opcao correta!"); goto Classe;}if (MC<=0) {printf ("\n Escolha a opcao correta!"); goto Classe;}
No trecho acima, é realizada a declaração da operação “Classe:” indica que
será apresentada o looping de reinício quando for declara em uma linha o comando “goto
Classe;”. Veja que o programa faz perguntas de qual classe deve ser o material a ser utilizado
para o projeto do vaso de pressão. O programa também dá três opções e caso nenhuma delas
seja digitada, ele reinicia a rotina a partir da linha que contém “Classe:”.
85
//Definicao da tensao admissivel do material pela temperatura de trabalho.switch (MC) {case 1: if (Temp<=350) {S = 969;} else if (Temp<=375) {S = 928;} else if (Temp<=400) {S = 847;}....................................... else if (Temp<=475) {S = 469;} else if (Temp<=500) {S = 357;} else if (Temp>500) {printf ("\n Nao aplicavel. Entre com outra temperatura!"); goto Temperatura;} break;}
O trecho apresentado nesse momento apresenta a rotina de escolha “switch-
case-break” e “if-else-if” aninhadas. O trecho não apresenta todos os “case” porque não é
interessante de ser mostrado nesse momento, pois todo o código-fonte se encontra no
Apêndice B. Vale salientar nesse momento que para cada “if-else-if” no seu “case”, ao final é
apresentada a função “goto Temperatura;”. Assim, o programa reiniciará na linha que contém
o a localização de “Temperatura:”, pois para cada “case” o programa efetua uma busca
interna.
//Definicao do coeficiente de eficiencia de solda.Grau_inspecao:printf ("\n Escolha o grau de inspecao de soldagem:");printf ("\n");printf ("\n [1] - Radiografia Total");printf ("\n [2] - Radiografia Parcial");printf ("\n [3] - Nao Radiografada");printf ("\n A escolha e:");scanf ("%d",&Grau);getchar ();if (Grau>=4) {printf ("\n Escolha a opcao correta!"); goto Grau_inspecao;}if (Grau<=0) {printf ("\n Escolha a opcao correta!"); goto Grau_inspecao;}
Foi apresentada agora uma simples rotina de repetição para a escolha do grau
de inspeção da solda. Caso a opção escolhida não seja nenhuma das listadas, o programa
86
ficará questionando até que seja definida uma opção válida.
Após a definição do grau de inspeção de solda, o programa entra em mais uma
rotina de escolha já apresentada. O “switch-case-break” é aplicado para atribuição do valor de
“E” que é o coeficiente de eficiência da solda, mas ao escolher o grau de inspeção e cair na
rotina do “switch-case-break” uma nova pergunta é executada dentro de cada “case”. É
questionado o tipo de soldagem aplicada no vaso de pressão. É fácil perceber que esse
problema é resolvido pela aplicação da rotina “if-else-if”. É utilizado nesse trecho abaixo a
função “goto” para cada “case”, essa aplicação se deve a aplicabilidade de repetição do
questionamento do programa caso a opção escolhida não seja válida. Observe:
switch (Grau) {case 1: Radiografada: printf ("\n Qual o tipo de solda?"); printf ("\n"); printf ("\n [1] - Solda de topo, feita por ambos os lados, ou procedimento equivalente,"); printf ("\n de forma a obter penetracao e fusao totais. (Excluem-se as soldas com"); printf ("\n mata-junta permanente)."); printf ("\n [2] - Solda de topo, feita por um so lado, com mata-junta permanente."); printf ("\n A escolha e:"); scanf ("%d",&Tipo); getchar ();....................................... if (Tipo==1) {E = 0.7;} else if (Tipo==2) {E = 0.65;} else if (Tipo!=1&&2) {printf ("\n Escolha o tipo de solda!"); goto Nao_Radiografada;} break;}
É realizado nesse momento pelo trecho de código-fonte abaixo, o cálculo da
espessura de projeto da chapa, a espessura mínima estrutural da chapa e a pressão máxima de
trabalho admissível aplicada no casco.
//Calculo do casco cilindrico.e = ((P*R)/((S*E)-(0.6*P)))+C;es = 2.5+(0.002*R)+C;PMTA = ((S*E*e)/(R+(0.6*e)));printf ("\n A espessura do costado e: %lf mm",e);printf ("\n A espessura para estabilidade estrutural: %lf mm",es);
87
printf ("\n Pressao maxima de trabalho admissivel: %lf Pa",PMTA);
O procedimento seguinte é a realização dos cálculos para espessura de chapa a
ser utilizada nos tampos do vaso de pressão e a pressão máxima de trabalho admissível
suportada pelos tampos. Os procedimentos apresentados já foram aplicados algumas vezes e
são de fácil percepção. Assim:
//Agora e iniciado a escolha e o calculo da espessura dos tamposprintf ("\n");printf ("\n Escolha o tipo de tampo:");printf ("\n\n [1] - Torrisferico");printf ("\n [2] - Conico");printf ("\n [3] - Plano");printf ("\n A escolha e:");scanf ("%d",&Tampo);getchar ();switch (Tampo) {case 1: e_Torri = ((P*R)/((S*E)-(0.1*P)))+C; e_Torri_PMTA = ((S*E*e_Torri)/(R+(0.1*e_Torri))); printf ("\n A espessura do tampo torrisferico e: %lf mm",e_Torri); printf ("\n Pressao maxima de trabalho admissivel no tampo: %lf Pa",e_Torri_PMTA); break;
case 2: printf ("\n Defina o semi-angulo do vertice do cone:"); scanf ("%lf",&alpha); getchar (); e_Cone = ((P*R)/(cos(DegToRad(alpha))*(S*E-(0.6*P))))+C; e_Cone_PMTA = ((S*E*e_Cone*cos(DegToRad(alpha)))/(R+(0.6*e_Cone*cos(DegToRad(alpha)))))+C; printf ("\n A espessura do tampo conico e: %lf mm",e_Cone); printf ("\n Pressao maxima de trabalho admissivel no tampo: %lf Pa",e_Cone_PMTA); break;
case 3: e_Reto = (sqrt((0.33*P)/(S*E)))+C; e_Reto_PMTA = ((127*S)/(2*R)); printf ("\n A espessura do tampo plano e: %lf mm",e_Reto); printf ("\n Pressao maxima de trabalho admissivel no tampo: %lf Pa",e_Reto_PMTA); break;}
O último passo se trata da geração e impressão de um relatório com tudo que
foi calculado e apresentado. Veja:
//Agora basta gerar o relatório de resultados.printf ("\n");
88
printf ("\n=============================================================================");printf ("\n RELATORIO DE RESULTADOS - '' VASOS DE PRESSAO ''");printf ("\n=============================================================================");printf ("\n---->> DADOS SOBRE O COSTADO: <<----");printf ("\n Raio interno em (m): %lf",R);printf ("\n Pressao interna de projeto (Pa): %lf",P);printf ("\n Sobreespesura para corrosao (mm): %lf",C);printf ("\n Temperatura de trabalho (oC): %lf",Temp);printf ("\n Tensao admissivel do material (kgf/cm2): %lf",S);printf ("\n Coeficiente de eficiencia de solda: %lf",E);printf ("\n A espessura do costado e (mm): %lf",e);printf ("\n A espessura para estabilidade estrutural (mm): %lf",es);printf ("\n Pressao maxima de trabalho admissivel (Pa): %lf",PMTA);printf ("\n=============================================================================");printf ("\n---->> DADOS SOBRE OS TAMPOS: <<----");if (Tampo==1) {printf ("\n Tipo de tampo: Torrisferico"); printf ("\n A espessura do tampo torrisferico e (mm): %lf",e_Torri); printf ("\n Pressao maxima de trabalho admissivel no tampo (Pa): %lf",e_Torri_PMTA);}else if (Tampo==2) {printf ("\n Tipo de tampo: Conico"); printf ("\n A espessura do tampo conico e (mm): %lf",e_Cone); printf ("\n Pressao maxima de trabalho admissivel no tampo (Pa): %lf",e_Cone_PMTA);}else if (Tampo==3) {printf ("\n Tipo de tampo: Plano"); printf ("\n A espessura do tampo plano e (mm): %lf",e_Reto); printf ("\n Pressao maxima de trabalho admissivel no tampo (Pa): %lf",e_Reto_PMTA);}printf ("\n=============================================================================");printf ("\n---->> DADOS GERAIS <<----");if (MC==1) {printf ("\n Classe do material: A-285-C (Aco carbono)");}if (MC==2) {printf ("\n Classe do material: A-387-11 c 11 (Aco-liga 1.1/4 Cr - 1/2 Mo)");}if (MC==3) {printf ("\n Classe do material: A-387-5 c 11 (Aco-liga 5 Cr - 1/2 Mo)");}if (Grau==1) {printf ("\n Grau da inspecao de soldagem: Radiografia Total");}if (Grau==2) {printf ("\n Grau de inspecao de soldagem: Radiografia Parcial");}if (Grau==3) {printf ("\n Grau de inspecao de soldagem: Nao Radiografada");}if (Tipo==1) {printf ("\n OBSERVACAO:"); printf ("\n Solda de topo, feita por ambos os lados, ou procedimento equivalente,"); printf ("\n de forma a obter penetracao e fusao totais. (Excluem-se as soldas com");
89
printf ("\n mata-junta permanente).\n\n");}if (Tipo==2) {printf ("\n OBSERVACAO"); printf ("\n Solda de topo, feita por um so lado, com mata-junta permanente.\n\n");}getchar ();return 0;}
90
CONCLUSÃO
A utilização da programação como ferramenta de trabalho para um futuro
Engenheiro é de extrema importância. A aplicação com o uso de ferramentas livres como o
Sistema Operacional Linux/GNU, programas de edição de textos e de compilação são
bastante importantes devido ao custo aproximadamente nulo. Dessa forma, além de ter sido
comprovada a viabilidade do uso de programas livres para o exercício da programação
computacional para Engenharias, os programas livres se tornam um meio de combate à
pirataria.
O trabalho também apresentou uma grande flexibilidade com relação as
diversas áreas da Engenharia. Os programas desenvolvidos apresentaram resultados bastante
satisfatórios, logo, a linguagem de programação “C” atende às necessidades dos programas
desenvolvidos para a área.
Melhorias e outros programas derivados dos apresentados podem ser realizados
de forma simples. As rotinas aplicadas nas soluções são bastante importantes na elaboração de
qualquer programa, independente a área de aplicação.
Objetivo da realização deste trabalho foi alcançado, pois foi apresentada
ferramentas computacionais que serviu para aplica os conhecimentos de programação e
engenharia.
91
REFERÊNCIAS
AMERICAN SOCIETY of MECHANICAL ENGINEERS. ASME SEC. VIII Div. I: Boiler and Pressure Vessel Code. New York: 648p. 2004.
ARAÚJO, E.C.C. – Trocadores de Calor, 1ª ed., EdUFSCAR, São Carlos, 2002.
CARVALHO, C. de O. FILHO. Trabalho Individual No. 1 (OBRIGATÓRIO) – Projeto de Dimensionamento de Trocadores de Calor. Proposta de Trabalho Acadêmico (Graduação em Engenharia Mecânica) – Centro de Tecnologia, Universidade Federal do Ceará, Fortaleza, 2007.
CARVALHO, C. de O. FILHO. Trabalho Individual No. 2 (OPCIONAL) – Projeto de Isolamento Térmico de Linhas de Vapor. Proposta de Trabalho Acadêmico (Graduação em Engenharia Mecânica) – Centro de Tecnologia, Universidade Federal do Ceará, Fortaleza, 2007.
CÂMARA, S. L.. Projeto deVigas Bi-apoiadas – PROVIG. 2006. Monografia (Graduação em Engenharia Mecânica) – Centro de Tecnologia, Universidade Federal do Ceará, Fortaleza, 2006.
GONSALES, D. JR.. Software para dimensionamento de vasos de pressão – DIVAP. 2006. Monografia (Graduação em Engenharia Mecânica) – Centro de Tecnologia, Universidade Federal do Ceará, Fortaleza, 2006.
HERBERT, S.. C – Completo e Total. 3ª ed. rev., São Paulo, SP: Makron Books Ed. , 1997.
HIBBELER, R.C. Resistência dos Materiais. 3ª ed. (Traduzida), Rio de Janeiro, RJ: Livros Técnicos e Científicos Ed. , 2000. cap. 11 e 12.
INCROPERA, F.P. e DEWITT, D.P. – Fundamentos de Transferência de Calor e de Massa, 5ª ed. (Traduzida), LTC, Rio de Janeiro, 2003. cap. 6, 7, 8, 9, 10.
KERNIGHAN, B. W., RITCHIE, D. M., The C Programming Language. Prentice Hall, Inc., 1988.
KREITH, F. e BOEHM, R.F. – Heat and Mass Transfer Mechanical Engineering Handbook, Ed. Frank Kreith, 1999.
MORAN, M.J., DEWITT, D.P., MUNSON, B.R. e SHAPIRO, H.N. – Introdução a Engenharia dos Sistemas Térmicos, 1ª ed., LTC, Rio de Janeiro, 2005.
SANTOS, H. J.. Curso de Linguagem C. 2000. Santos, SP: UNISANTOS.
TELLES, Pedro Carlos da Silva. Vasos de pressão. Rio de Janeiro, RJ: Livros Técnicos e Científicos Ed., 1991.
92
APÊNDICE A – Fontes de informação para instalação do Ubuntu
http://img01.link.estadao.com.br/multimidia/infografico/InstalarLinux.pdf
http://br-linux.org/linux/tutorial_de_instalao_do_ubuntu_6.06
http://www.gnx.com.br/apostilas/apostila-Ubuntu-Instalacao-GPL.pdf
http://www.guiaubuntupt.org/wiki/index.php?title=Como_instalar_tudo_em_Ubuntu
http://glua.ua.pt/Suporte/Ubuntu?action=AttachFile&do=get&target=iuni.pdf
http://www.guiadohardware.net/comunidade/ubuntu-particoes/272726/
http://www.forumpcs.com.br/viewtopic.php?t=128477
http://wiki.meyer.eti.br/_media/howto/ubuntu-feisty-install.pdf
http://ubuntuforum-br.org/
http://ubuntuforums.org/
http://www.linuxforums.org/forum/ubuntu-help/
93
APÊNDICE B – Códigos-fonte dos programas abordados
Exemplo referente a Figura 3.1.1
#include <stdio.h> #include <stdlib.h> #include <math.h> //----------------------------------- main () { printf ("Nao faz nada!\n"); return 0; }
Exemplo referente a Figura 3.2.1
#include <stdio.h> #include <stdlib.h> #include <math.h> //----------------------------------- main () { double x, y, z; printf ("\nVamos somar dois numeros."); printf ("\n\nDigite o valor de x:"); scanf ("%lf",&x); getchar (); printf ("Digite o valor de y:"); scanf ("%lf",&y); getchar (); z=x+y; printf ("z e igual a: %lf\n",z); getchar (); return 0; }
Exemplo referente a Figura 3.3.1
#include <stdio.h> #include <stdlib.h> #include <math.h> //----------------------------------- main () { double x, y; printf("\nEntre com o ângulo para calcularmos o seno:"); scanf("%lf",&x); getchar(); y = sin((x*M_PI)/180); printf ("\nO valor do seno e: %lf\n",y); getchar(); return 0; }
Exemplo referente a Figura 3.3.2
#include <stdio.h> #include <stdlib.h> #include <math.h> //----------------------------------- double DegToRad (double x)
94
{return (x*M_PI/180);} //----------------------------------- main () { double x, y; printf("\nEntre com o ângulo para calcularmos o seno:"); scanf("%lf",&x); getchar(); y = sin(DegToRad(x)); printf ("\nO valor do seno e: %lf\n",y); getchar(); return 0; }
Dimensionamento de isolamento térmico em linha de vapor
#include <stdio.h> #include <stdlib.h> #include <math.h>
//------------------------------------------------------------------------------
main () { inicio: printf ("\n DIMENSIONAMENTO DE ISOLAMENTO TERMICO EM LINHA DE VAPOR"); printf ("\n\n\n 1 - Determina a espessura do isolamento a partir da queda de temperatura."); printf ("\n 2 - Determina a queda de temperatura a partir da espessura do isolamento."); printf ("\n 3 - Finalizar o programa."); printf ("\n\n\n Escolha a Situacao:"); int x; scanf ("%d",&x); if (x==1) { double R1, R2, R3, KI, KT, H, L, VAZAO, Cp, e, vazao, C0, C1, C2, C3, Teta, TI, TA, Tsi, RC, Funcao, T_int, T_ext, PESO, Qr, dT, Ro, G, Eiso, dTporL, L1, L2, T1, T2; printf ("\n Espeficique a diametro externo do tubo (m): ");
scanf ("%lf",&R2); printf (" Especifique a espessura da parede do tubo (m): "); scanf ("%lf",&e); R1 = R2-e;
printf ("\n Escolha o material do tubo:\n"); printf (" 1 - Tubo de aco carbono ANSI 1010.\n"); printf (" 2 - Tubo de aco INOX ANSI 304.\n"); printf (" 3 - Tudo de bronze comercial.\n"); printf (" Escolha: "); int KTubo; scanf ("%d",&KTubo); if (KTubo == 1)
{KT = 63.9;} //Tubo de aço carbono ANSI 1010. if (KTubo == 2)
{KT = 14.9;} //Tubo de aço INOX ANSI 304. if (KTubo == 3)
{KT = 52;} //Tubo de bronze comercial. printf ("\n Escolha o material do isolamento termico:\n"); printf (" 1 - Manta de la de vidro.\n"); printf (" 2 - Tubo bi-partido de la de rocha.\n"); printf (" 3 - Flocos de la de rocha.\n"); printf (" Escolha: "); int KIsolamento; scanf ("%d",&KIsolamento); if (KIsolamento == 1)
{KI = 0.025; Ro = 40;}
if (KIsolamento == 2) {KI = 0.046; Ro = 130;}
if (KIsolamento == 3) {KI = 0.037;
95
Ro = 60;} H = 30; //Coeficiente de convecção externa.
printf ("\n Informe o comprimento da tubulacao (m): "); scanf ("%lf",&L); printf (" Informe a vazao massica do vapor (kg/s): "); scanf ("%lf",&vazao);
VAZAO = vazao/3600; printf (" Informe a temperatura do vapor (oC): "); scanf ("%lf",&T_int); printf (" Informe a temperatura do ambiente (oC): "); scanf ("%lf",&T_ext);
TI = T_int+273.15; TA = T_ext+273.15; Teta = TI/1000; C0 = 1.79; C1 = 0.107*Teta; C2 = 0.586*Teta*Teta; C3 = -0.2*Teta*Teta*Teta; G = 9.81; Cp = (C0+C1+C2+C3)*1000; R3 = R2; printf (" Informe a queda de temperatura na linha (oC/m):"); scanf ("%lf",&dTporL); Funcao = ((TI-TA)/((((log(R2/R1)))/(2*M_PI*KT*L))+(((log(R3/R2)))/(2*M_PI*KI*L))+(1/(H*2*M_PI*R3*L))))/(VAZAO*Cp); while (((dTporL*L)/Funcao)<1) { R3 = R3+0.0000001; Funcao = ((TI-TA)/((((log(R2/R1)))/(2*M_PI*KT*L))+(((log(R3/R2)))/(2*M_PI*KI*L))+(1/(H*2*M_PI*R3*L))))/(VAZAO*Cp); } Eiso = R3-R2; printf ("\n Espessura do isolamento recomendada ========================> %5.4lf (m)", Eiso); L1 = log(R2/R1); L2 = log(R3/R2); T1 = (L1*H*R3)/KT; T2 = (L2*H*R3)/KI; Tsi = ((TI/(T1+T2))+TA)/((1/(T1+T2))+1)-273.15; printf ("\n Temperatura da superficie externa do isolamento ============> %5.2lf oC", Tsi); PESO = G*Ro*(R3*R3-R2*R2)*M_PI; RC = (KI/H); printf ("\n O peso do isolamento em kgf/m ==============================> %5.3lf N/m", PESO); printf ("\n O raio critico do isolamento ===============================> %5.5lf m", RC); if (RC<R1) { printf ("\n\n Como o raio do tubo e maior do que o raio critico, qualquer adicao de"); printf ("\n camadas de isolamento ira aumentar a resistencia total e portanto"); printf ("\n diminuindo a perda de calor."); } else { printf ("\n\n Como o raio do tubo e menor que o raio critico, a resistencia total"); printf ("\n diminui e, portanto, a taxa de calor aumenta com a adicao de camadas"); printf ("\n de isolamento."); } printf ("\n\n\n Pressione a tecla ENTER para reiniciar."); getchar(); getchar(); goto inicio; } if (x==2) { double R1, R2, R3, KI, KT, H, L, VAZAO, Cp, T1, T2, T_int, T_ext, C0, C1, C2, C3, Teta, TI, TA, Tsi, RC, L1, L2, e, vazao, D1, D2, PESO, Qr, dT, Ro, G, Eiso, dTporL, Q1, Q2, Q3; printf ("\n Espeficique a diametro externo do tubo (m): ");
scanf ("%lf",&R2); printf (" Especifique a espessura da parede do tubo (m): ");
96
scanf ("%lf",&e); R1 = R2-e;
printf ("\n Escolha o material do tubo:\n"); printf (" 1 - Tubo de aco carbono ANSI 1010.\n"); printf (" 2 - Tubo de aco INOX ANSI 304.\n"); printf (" 3 - Tudo de bronze comercial.\n"); printf (" Escolha: "); int KTubo; scanf ("%d",&KTubo); if (KTubo == 1)
{KT = 63.9;} //Tubo de aço carbono ANSI 1010. if (KTubo == 2)
{KT = 14.9;} //Tubo de aço INOX ANSI 304. if (KTubo == 3)
{KT = 52;} //Tubo de bronze comercial. printf ("\n Escolha o material do isolamento termico:\n"); printf (" 1 - Manta de la de vidro.\n"); printf (" 2 - Tubo bi-partido de la de rocha.\n"); printf (" 3 - Flocos de la de rocha.\n"); printf (" Escolha: "); int KIsolamento; scanf ("%d",&KIsolamento); if (KIsolamento == 1)
{KI = 0.025; Ro = 40;}
if (KIsolamento == 2) {KI = 0.046; Ro = 130;}
if (KIsolamento == 3) {KI = 0.037; Ro = 60;}
H = 30; printf ("\n Informe o comprimento da tubulacao (m): "); scanf ("%lf",&L); printf (" Informe a vazao massica do vapor (kg/s): "); scanf ("%lf",&vazao);
VAZAO = vazao/3600; printf (" Informe a temperatura do vapor (oC): "); scanf ("%lf",&T_int); printf (" Informe a temperatura do ambiente (oC): "); scanf ("%lf",&T_ext);
TI = T_int+273.15; TA = T_ext+273.15; Teta = TI/1000; C0 = 1.79; C1 = 0.107*Teta; C2 = 0.586*Teta*Teta; C3 = -0.2*Teta*Teta*Teta; G = 9.81; Cp = (C0+C1+C2+C3)*1000; printf (" Espessura do isolamento desejado (m):"); scanf ("%lf",&Eiso); R3 = R2+Eiso; L1 = log(R2/R1); L2 = log(R3/R2); D1 = 2*M_PI*KT*L; D2 = 2*M_PI*KI*L; Q1 = L1/D1; Q2 = L2/D2; Q3 = 1/(2*M_PI*R3*H*L); Qr = (TI-TA)/(Q1+Q2+Q3); dT = (Qr)/(VAZAO*Cp); dTporL = dT/L; T1 = (L1*H*R3)/KT; T2 = (L2*H*R3)/KI; Tsi = ((TI/(T1+T2))+TA)/((1/(T1+T2))+1)-273.15; PESO = G*Ro*(R3*R3-R2*R2)*M_PI; RC = (KI/H); printf ("\n A queda de temperatura na linha por unidade de comprimento => %5.9lf oC/m", dTporL); printf ("\n Temperatura da superficie externa do isolamento ============> %5.2lf oC", Tsi); printf ("\n O peso do isolamento em kgf/m ==============================> %5.3lf N/m", PESO); printf ("\n O raio critico do isolamento ===============================> %5.5lf m", RC);
97
if (RC<R1) { printf ("\n\n Como o raio do tubo e maior do que o raio critico, qualquer adicao de"); printf ("\n camadas de isolamento ira aumentar a resistencia total e portanto"); printf ("\n diminuindo a perda de calor."); } else { printf ("\n\n Como o raio do tubo e menor que o raio critico, a resistencia total"); printf ("\n diminui e, portanto, a taxa de calor aumenta com a adicao de camadas"); printf ("\n de isolamento."); } printf ("\n\n\n Pressione a tecla ENTER para reiniciar."); getchar(); getchar(); goto inicio; } if (x==3) { return 0; } getchar(); return 0; }
Projeto de um trocador de calor do tipo casco e tubos (água – óleo)
#include <stdio.h> #include <stdlib.h> #include <math.h> //--------------------------------------------------------------------------- main () { //Declaração de algumas constantes e variáveis. int x, y, w; double TempHE, dHE, cpHE, uHE, vHE, kHE, aHE, PrHE, TempHM, PI, TempHEntrada, TempHSaida, TempHS, dHS, cpHS, uHS, vHS, kHS, aHS, PrHS, mH, U, dTempC, mc, RedTubo, f, factor001, factor002, NudTubo, ht, R, S, F, factor003, factor004, factor005, factor006, factor007, L, DeltaTempLM, Atroca, DcascoIN, Razao, VolH2O, NudCasco, hc, mh, q, Dtubo, Dcasco, N, dTempH, Bocal, P, Nf, C, Passo, m, n, Abocal, Q, V, Vmax, RedCasco, vHM, kHM, aHM, PrHM, dHM, cpHM, uHM, TempCE, TempCS, TempCM, dCE, cpCE, uCE, kCE, PrCE, dCS, cpCS, uCS, kCS, PrCS, TempCEntrada, TempCSaida, dCM, cpCM, uCM, kCM, PrCM, Acalculada, Excesso;
//Mensagem de informação do programa. printf ("\n\n SOFTWARE PARA DIMENSIONAMENTO DE"); printf ("\n TROCADOR DE CALOR DO TIPO CASCO E TUBO"); printf ("\n\n ===== \n"); printf (" | | \n"); printf (" |---|----------------------|---| \n"); printf (" | ||====================|| | \n"); printf (" || | ||====================|| | ||\n"); printf (" ||--- ||====================|| ---||\n"); printf (" ||--- ||====================|| ---||\n"); printf (" || | ||====================|| | ||\n"); printf (" | ||====================|| | \n"); printf (" |---|----------------------|---| \n"); printf (" | | \n"); printf (" ===== \n");
//Entrada dos valores da temperatura de entrada e saída do óleo. printf ("\n OBSERVACOES:"); printf ("\n 1 - A temperatura do oleo deve estar na faixa de (-0.15 <-> 156.85) oC,"); printf ("\n pois corresponde a tabela encotrada em literatura."); printf ("\n 2 - A temperatura da agua deve estar na faixa de (0 <-> 91.85) oC,");
98
printf ("\n pois corresponde a tabela encotrada em literatura."); printf ("\n 3 - A agua entra pelo feixe de tubos e o oleo pelo casco, isso se deve,"); printf ("\n a literatura recomenda que o fluido quente passe pelo casco."); printf ("\n 4 - O trocador e do tipo 'contra corrente' pois trocadores desse tipo,"); printf ("\n apresentam melhor troca termica."); printf ("\n\n Entre com o valor da temperatura de entrada (quente) do oleo (oC): "); scanf ("%lf",&TempHEntrada); getchar (); printf (" Entre com o valor da temperatura de saida (fria) do oleo (oC): "); scanf ("%lf",&TempHSaida); getchar ();
//Busca de TempHM pelos valores menores e maiores. TempHM = (TempHEntrada+TempHSaida)/2;
//1a. parte da interpolação. if (TempHM<=-0.15) {TempHE = -0.15; dHE = 889.1; cpHE = 1796; uHE = 3.85; vHE = 0.004280; kHE = 0.147; aHE = 0.0000000910; PrHE = 47000; goto fimTempHE;} if (TempHM<=6.85) {TempHE = 6.85; dHE = 895.3; cpHE = 1827; uHE = 2.17; vHE = 0.002430; kHE = 0.144; aHE = 0.0000000880; PrHE = 27500; goto fimTempHE;} if (TempHM<=16.85) {TempHE = 16.85; dHE = 890.0; cpHE = 1868; uHE = 0.999; vHE = 0.001120; kHE = 0.145; aHE = 0.0000000872; PrHE = 12900; goto fimTempHE;} if (TempHM<=26.85) {TempHE = 26.85; dHE = 884.1; cpHE = 1909; uHE = 0.486; vHE = 0.000550; kHE = 0.145; aHE = 0.0000000859; PrHE = 6400; goto fimTempHE;} if (TempHM<=36.85) {TempHE = 36.85; dHE = 877.9; cpHE = 1951; uHE = 0.253; vHE = 0.000288; kHE = 0.145; aHE = 0.0000000847; PrHE = 3400; goto fimTempHE;} if (TempHM<=46.85) {TempHE = 46.85; dHE = 871.8; cpHE = 1993; uHE = 0.141; vHE = 0.000161; kHE = 0.143; aHE = 0.0000000823;
99
PrHE = 1965; goto fimTempHE;} if (TempHM<=56.85) {TempHE = 56.85; dHE = 865.8; cpHE = 2035; uHE = 0.0836; vHE = 0.0000966; kHE = 0.141; aHE = 0.0000000800; PrHE = 1205; goto fimTempHE;} if (TempHM<=66.85) {TempHE = 66.85; dHE = 859.9; cpHE = 2076; uHE = 0.0531; vHE = 0.0000617; kHE = 0.139; aHE = 0.0000000779; PrHE = 793; goto fimTempHE;} if (TempHM<=76.85) {TempHE = 76.85; dHE = 853.9; cpHE = 2118; uHE = 0.0356; vHE = 0.0000417; kHE = 0.138; aHE = 0.0000000763; PrHE = 546; goto fimTempHE;} if (TempHM<=86.85) {TempHE = 86.85; dHE = 847.8; cpHE = 2161; uHE = 0.0252; vHE = 0.0000297; kHE = 0.138; aHE = 0.0000000753; PrHE = 395; goto fimTempHE;} if (TempHM<=96.85) {TempHE = 96.85; dHE = 841.8; cpHE = 2206; uHE = 0.0186; vHE = 0.0000220; kHE = 0.137; aHE = 0.0000000738; PrHE = 300; goto fimTempHE;} if (TempHM<=106.85) {TempHE = 106.85; dHE = 836.0; cpHE = 2250; uHE = 0.0141; vHE = 0.0000169; kHE = 0.136; aHE = 0.0000000723; PrHE = 233; goto fimTempHE;} if (TempHM<=116.85) {TempHE = 116.85; dHE = 830.6; cpHE = 2294; uHE = 0.0110; vHE = 0.0000133; kHE = 0.135; aHE = 0.0000000709; PrHE = 187; goto fimTempHE;} if (TempHM<=126.85) {TempHE = 126.85; dHE = 825.1; cpHE = 2337;
100
uHE = 0.00874; vHE = 0.0000106; kHE = 0.134; aHE = 0.0000000695; PrHE = 152; goto fimTempHE;} if (TempHM<=136.85) {TempHE = 136.85; dHE = 818.9; cpHE = 2381; uHE = 0.00698; vHE = 0.00000852; kHE = 0.133; aHE = 0.0000000682; PrHE = 125; goto fimTempHE;} if (TempHM<=146.85) {TempHE = 146.85; dHE = 812.1; cpHE = 2427; uHE = 0.00564; vHE = 0.00000694; kHE = 0.133; aHE = 0.0000000675; PrHE = 103; goto fimTempHE;} if (TempHM<=156.85) {TempHE = 156.85; dHE = 806.5; cpHE = 2471; uHE = 0.00470; vHE = 0.00000583; kHE = 0.132; aHE = 0.0000000662; PrHE = 88;} fimTempHE:
//Continuação da 2a. parte para interpolação. if (TempHM>=156.85) {TempHS = 156.85; dHS = 806.5; cpHS = 2471; uHS = 0.00470; vHS = 0.00000583; kHS = 0.132; aHS = 0.0000000662; PrHS = 88; goto fimTempHS;} if (TempHM>=146.85) {TempHS = 146.85; dHS = 812.1; cpHS = 2427; uHS = 0.00564; vHS = 0.00000694; kHS = 0.133; aHS = 0.0000000675; PrHS = 103; goto fimTempHS;} if (TempHM>=136.85) {TempHS = 136.85; dHS = 818.9; cpHS = 0.00698; vHS = 0.00000852; kHS = 0.133; aHS = 0.0000000682; PrHS = 125; goto fimTempHS;} if (TempHM>=126.85) {TempHS = 126.85; dHS = 825.1; cpHS = 2337; uHS = 0.00874; vHS = 0.0000106; kHS = 0.134; aHS = 0.0000000695;
101
PrHS = 152; goto fimTempHS;} if (TempHM>=116.85) {TempHS = 116.85; dHS = 830.6; cpHS = 2294; uHS = 0.0110; vHS = 0.0000133; kHS = 0.135; aHS = 0.0000000709; PrHS = 187; goto fimTempHS;} if (TempHM>=106.85) {TempHS = 106.85; dHS = 836.0; cpHS = 2250; uHS = 0.0141; vHS = 0.0000169; kHS = 0.136; aHS = 0.0000000723; PrHS = 233; goto fimTempHS;} if (TempHM>=96.85) {TempHS = 96.85; dHS = 841.8; cpHS = 2206; uHS = 0.0186; vHS = 0.0000220; kHS = 0.137; aHS = 0.0000000738; PrHS = 300; goto fimTempHS;} if (TempHM>=86.85) {TempHS = 86.85; dHS = 847.8; cpHS = 2161; uHS = 0.0252; vHS = 0.0000297; kHS = 0.138; aHS = 0.0000000753; PrHS = 395; goto fimTempHS;} if (TempHM>=76.85) {TempHS = 76.85; dHS = 853.9; cpHS = 2118; uHS = 0.0356; vHS = 0.0000417; kHS = 0.138; aHS = 0.0000000763; PrHS = 546; goto fimTempHS;} if (TempHM>=66.85) {TempHS = 66.85; dHS = 859.9; cpHS = 2076; uHS = 0.0531; vHS = 0.0000617; kHS = 0.139; aHS = 0.0000000779; PrHS = 793; goto fimTempHS;} if (TempHM>=56.85) {TempHS = 56.85; dHS = 865.8; cpHS = 2035; uHS = 0.0836; vHS = 0.0000966; kHS = 0.141; aHS = 0.0000000800; PrHS = 1205; goto fimTempHS;} if (TempHM>=46.85) {TempHS = 46.85; dHS = 871.8; cpHS = 1993;
102
uHS = 0.141; vHS = 0.000161; kHS = 0.143; aHS = 0.0000000823; PrHS = 1965; goto fimTempHS;} if (TempHM>=36.85) {TempHS = 36.85; dHS = 877.9; cpHS = 1951; uHS = 0.253; vHS = 0.000288; kHS = 0.145; aHS = 0.0000000847; PrHS = 3400; goto fimTempHS;} if (TempHM>=26.85) {TempHS = 26.85; dHS = 884.1; cpHS = 1909; uHS = 0.486; vHS = 0.000550; kHS = 0.145; aHS = 0.0000000859; PrHS = 6400; goto fimTempHS;} if (TempHM>=16.85) {TempHS = 16.85; dHS = 890.0; cpHS = 1868; uHS = 0.999; vHS = 0.001120; kHS = 0.145; aHS = 0.0000000872; PrHS = 12900; goto fimTempHS;} if (TempHM>=6.85) {TempHS = 6.85; dHS = 895.3; cpHS = 1827; uHS = 2.17; vHS = 0.002430; kHS = 0.144; aHS = 0.0000000880; PrHS = 27500; goto fimTempHS;} if (TempHM>=-0.15) {TempHS = -0.15; dHS = 889.1; cpHS = 1796; uHS = 3.85; vHS = 0.004280; kHS = 0.147; aHS = 0.0000000910; PrHS = 47000;} fimTempHS: //Cálculos de interpolações. vHM = (((TempHM-TempHE)*(vHS-vHE))/(TempHS-TempHE))+vHE; kHM = (((TempHM-TempHE)*(kHS-kHE))/(TempHS-TempHE))+kHE; aHM = (((TempHM-TempHE)*(aHS-aHE))/(TempHS-TempHE))+aHE; PrHM = (((TempHM-TempHE)*(PrHS-PrHE))/(TempHS-TempHE))+PrHE; dHM = (((TempHM-TempHE)*(dHS-dHE))/(TempHS-TempHE))+dHE; cpHM = (((TempHM-TempHE)*(cpHS-cpHE))/(TempHS-TempHE))+cpHE; uHM = (((TempHM-TempHE)*(uHS-uHE))/(TempHS-TempHE))+uHE;
//Entrada do valor da vazão do óleo. printf ("\n Entre com a vazao do oleo (L/min): "); scanf ("%lf",&mH); getchar ();
//Cálculos a partir da vazão do óleo fornecida. P = 0.01905;
103
mh = (mH/60)*(dHM/1000); dTempH = TempHEntrada-TempHSaida; q = mh*cpHM*dTempH;
//Escolha do diâmetro do tubo. printf ("\n Escolha o diametro do tubo do feixe: "); printf ("\n 1 - Tubo de 3/8 in."); printf ("\n 2 - Tubo de 1/2 in."); printf ("\n 3 - Tubo de 5/8 in."); printf ("\n A escolha e: "); scanf ("%d",&x); getchar (); if (x==1) {Dtubo = 0.009525;} if (x==2) {Dtubo = 0.0127;} if (x==3) {Dtubo = 0.015875;}
//Escolha a configuração do trocador nos parâmetros abaixo. printf ("\n Escolha a configuracao do trocador de calor: "); printf ("\n 1 - 12 tubos, 1 passo, 3 in de casco"); printf ("\n 2 - 16 tubos, 1 passo, 3.5 in de casco"); printf ("\n 3 - 16 tubos, 1 passo, 4 in de casco"); printf ("\n 4 - 36 tubos, 1 passo, 5 in de casco"); printf ("\n 5 - 52 tubos, 1 passo, 6 in de casco"); printf ("\n 6 - 88 tubos, 1 passo, 8 in de casco"); printf ("\n 7 - 148 tubos, 1 passo, 10 in de casco"); printf ("\n 8 - 208 tubos, 1 passo, 12 in de casco"); printf ("\n 9 - 6 tubos, 2 passos, 3 in de casco"); printf ("\n 10 - 8 tubos, 2 passos, 3.5 in de casco"); printf ("\n 11 - 8 tubos, 2 passos, 4 in de casco"); printf ("\n 12 - 18 tubos, 2 passos, 5 in de casco"); printf ("\n 13 - 26 tubos, 2 passos, 6 in de casco"); printf ("\n 14 - 44 tubos, 2 passos, 8 in de casco"); printf ("\n 15 - 74 tubos, 2 passos, 10 in de casco"); printf ("\n 16 - 104 tubos, 2 passos, 12 in de casco"); printf ("\n 17 - 3 tubos, 4 passos, 3 in de casco"); printf ("\n 18 - 4 tubos, 4 passos, 3,5 in de casco"); printf ("\n 19 - 4 tubos, 4 passos, 4 in de casco"); printf ("\n 20 - 9 tubos, 4 passos, 5 in de casco"); printf ("\n 21 - 13 tubos, 4 passos, 6 in de casco"); printf ("\n 22 - 22 tubos, 4 passos, 8 in de casco"); printf ("\n 23 - 37 tubos, 4 passos, 10 in de casco"); printf ("\n 24 - 52 tubos, 4 passos, 12 in de casco"); printf ("\n A escolha e: "); scanf ("%d",&y); getchar (); if (y==1) {N = 12; Dcasco = 3*0.0254; Nf = 4; C = 0.90; Passo = 1;} if (y==2) {N = 16; Dcasco = 3.5*0.0254; Nf = 4; C = 0.90; Passo = 1;} if (y==3) {N = 16; Dcasco = 4*0.0254; Nf = 4; C = 0.90; Passo = 1;} if (y==4) {N = 36; Dcasco = 5*0.0254; Nf = 6; C = 0.95; Passo = 1;} if (y==5) {N = 52;
104
Dcasco = 6*0.0254; Nf = 7; C = 0.96; Passo = 1;} if (y==6) {N = 88; Dcasco = 8*0.0254; Nf = 9; C = 0.98; Passo = 1;} if (y==7) {N = 148; Dcasco = 10*0.0254; Nf = 12; C = 0.99; Passo = 1;} if (y==8) {N = 208; Dcasco = 12*0.0254; Nf = 14; C = 0.99; Passo = 1;} if (y==9) {N = 6; Dcasco = 3*0.0254; Nf = 4; C = 0.90; Passo = 2;} if (y==10) {N = 8; Dcasco = 3.5*0.0254; Nf = 4; C = 0.90; Passo = 2;} if (y==11) {N = 8; Dcasco = 4*0.0254; Nf = 4; C = 0.90; Passo = 2;} if (y==12) {N = 18; Dcasco = 5*0.0254; Nf = 6; C = 0.95; Passo = 2;} if (y==13) {N = 26; Dcasco = 6*0.0254; Nf = 7; C = 0.96; Passo = 2;} if (y==14) {N = 44; Dcasco = 8*0.0254; Nf = 9; C = 0.98; Passo = 2;} if (y==15) {N = 74; Dcasco = 10*0.0254; Nf = 12; C = 0.99; Passo = 2;} if (y==16) {N = 104; Dcasco = 12*0.0254; Nf = 14; C = 0.99; Passo = 2;} if (y==17) {N = 3; Dcasco = 3*0.0254; Nf = 4; C = 0.90; Passo = 4;}
105
if (y==18) {N = 4; Dcasco = 3.5*0.0254; Nf = 4; C = 0.90; Passo = 4;} if (y==19) {N = 4; Dcasco = 4*0.0254; Nf = 4; C = 0.90; Passo = 4;} if (y==20) {N = 9; Dcasco = 5*0.0254; Nf = 6; C = 0.95; Passo = 4;} if (y==21) {N = 13; Dcasco = 6*0.0254; Nf = 7; C = 0.96; Passo = 4;} if (y==22) {N = 22; Dcasco = 8*0.0254; Nf = 9; C = 0.98; Passo = 4;} if (y==23) {N = 37; Dcasco = 10*0.0254; Nf = 12; C = 0.99; Passo = 4;} if (y==24) {N = 52; Dcasco = 12*0.0254; Nf = 14; C = 0.99; Passo = 4;}
//Escolha o bocal de entrada do óleo. printf ("\n Escolha o diametro do tubo do bocal de entrada do oleo:"); printf ("\n 1 - Bocal de 1 in"); printf ("\n 2 - Bocal de 1.5 in"); printf ("\n 3 - Bocal de 2 in"); printf ("\n A escolha e: "); scanf ("%d",&w); if (w==1) {Bocal = 0.0254;} if (w==2) {Bocal = 0.0381;} if (w==3) {Bocal = 0.0508;}
//Calculos complementares como: No. de Reynolds, área da secção do bocal e etc. Abocal = M_PI*(Bocal/2)*(Bocal/2); Q = (mH*0.001)/60; V = Q/Abocal; Vmax = (P*V)/(P-Dtubo); RedCasco = (dHM*Vmax*Dtubo)/uHM; if (RedCasco<=100) {m = 0.4; n = 0.36;} else if (RedCasco<=1000) {m = 0.5; n = 0.36;} else if (RedCasco<=200000) {m = 0.63; n = 0.36;} else if(RedCasco<=2000000) {m = 0.8;
106
n = 0.4;}
//Dados de temperatura da água de entrada e saída desejadas. printf ("\n Entre com o valor da temperatura de entrada (fria) da agua (oC): "); scanf ("%lf",&TempCEntrada); getchar (); printf (" Entre com o valor da temperatura de saida (quente) da agua (oC): "); scanf ("%lf",&TempCSaida); getchar ();
//Busca de TempCM pelos valores menores e maiores. TempCM = (TempCEntrada+TempCSaida)/2;
//1a. parte da interpolação. if (TempCM<=0) {TempCE = 0; dCE = 1; cpCE = 4217; uCE = 0.001750; kCE = 0.569; PrCE = 12.99; goto fimTempCE;} if (TempCM<=1.85) {TempCE = 1.85; dCE = 1; cpCE = 4211; uCE = 0.001652; kCE = 0.574; PrCE = 12.22; goto fimTempCE;} if (TempCM<=6.85) {TempCE = 6.85; dCE = 1; cpCE = 4198; uCE = 0.001422; kCE = 0.582; PrCE = 10.26; goto fimTempCE;} if (TempCM<=11.85) {TempCE = 11.85; dCE = 1; cpCE = 4189; uCE = 0.001225; kCE = 0.590; PrCE = 8.81; goto fimTempCE;} if (TempCM<=16.85) {TempCE = 16.85; dCE = 1.001; cpCE = 4184; uCE = 0.001080; kCE = 0.598; PrCE = 7.56; goto fimTempCE;} if (TempCM<=21.85) {TempCE = 21.85; dCE = 1.002; cpCE = 4181; uCE = 0.000959; kCE = 0.606; PrCE = 6.62; goto fimTempCE;} if (TempCM<=26.85) {TempCE = 26.85; dCE = 1.003; cpCE = 4179; uCE = 0.000855; kCE = 0.613; PrCE = 5.83; goto fimTempCE;} if (TempCM<=31.85) {TempCE = 31.85; dCE = 1.005;
107
cpCE = 4178; uCE = 0.000769; kCE = 0.620; PrCE = 5.20; goto fimTempCE;} if (TempCM<=36.85) {TempCE = 36.85; dCE = 1.007; cpCE = 4178; uCE = 0.000695; kCE = 0.628; PrCE = 4.62; goto fimTempCE;} if (TempCM<=41.85) {TempCE = 41.85; dCE = 1.009; cpCE = 4179; uCE = 0.000631; kCE = 0.634; PrCE = 4.16; goto fimTempCE;} if (TempCM<=46.85) {TempCE = 46.85; dCE = 1.011; cpCE = 4180; uCE = 0.000577; kCE = 0.640; PrCE = 3.77; goto fimTempCE;} if (TempCM<=51.85) {TempCE = 51.85; dCE = 1.013; cpCE = 4182; uCE = 0.000528; kCE = 0.645; PrCE = 3.42; goto fimTempCE;} if (TempCM<=56.85) {TempCE = 56.85; dCE = 1.016; cpCE = 4184; uCE = 0.000489; kCE = 0.650; PrCE = 3.15; goto fimTempCE;} if (TempCM<=61.85) {TempCE = 61.85; dCE = 1.018; cpCE = 4186; uCE = 0.000453; kCE = 0.656; PrCE = 2.88; goto fimTempCE;} if (TempCM<=66.85) {TempCE = 66.85; dCE = 1.021; cpCE = 4188; uCE = 0.000420; kCE = 0.660; PrCE = 2.66; goto fimTempCE;} if (TempCM<=71.85) {TempCE = 71.85; dCE = 1.024; cpCE = 4191; uCE = 0.000389; kCE = 0.668; PrCE = 2.45; goto fimTempCE;} if (TempCM<=76.85) {TempCE = 76.85; dCE = 1.027; cpCE = 4195; uCE = 0.000365; kCE = 0.668; PrCE = 2.29;
108
goto fimTempCE;} if (TempCM<=81.85) {TempCE = 81.85; dCE = 1.030; cpCE = 4199; uCE = 0.000343; kCE = 0.671; PrCE = 2.14; goto fimTempCE;} if (TempCM<=86.85) {TempCE = 86.85; dCE = 1.034; cpCE = 4203; uCE = 0.000324; kCE = 0.674; PrCE = 2.02; goto fimTempCE;} if (TempCM<=91.85) {TempCE = 91.85; dCE = 1.038; cpCE = 4209; uCE = 0.000306; kCE = 0.677; PrCE = 1.91; goto fimTempCE;} fimTempCE: //Continuação da 2a. parte para interpolação. if (TempCM>=91.85) {TempCS = 91.85; dCS = 1.038; cpCS = 4209; uCS = 0.000306; kCS = 0.677; PrCS = 1.91; goto fimTempCS;} if (TempCM>=86.85) {TempCS = 86.85; dCS = 1.034; cpCS = 4203; uCS = 0.000324; kCS = 0.674; PrCS = 2.02; goto fimTempCS;} if (TempCM>=81.85) {TempCS = 81.85; dCS = 1.030; cpCS = 4199; uCS = 0.000343; kCS = 0.671; PrCS = 2.14; goto fimTempCS;} if (TempCM>=76.85) {TempCS = 76.85; dCS = 1.027; cpCS = 4195; uCS = 0.000365; kCS = 0.668; PrCS = 2.29; goto fimTempCS;} if (TempCM>=71.85) {TempCS = 71.85; dCS = 1.024; cpCS = 4191; uCS = 0.000389; kCS = 0.668; PrCS = 2.45; goto fimTempCS;} if (TempCM>=66.85) {TempCS = 66.85; dCS = 1.021; cpCS = 4188; uCS = 0.000420; kCS = 0.660; PrCS = 2.66;
109
goto fimTempCS;} if (TempCM>=61.85) {TempCS = 61.85; dCS = 1.018; cpCS = 4186; uCS = 0.000453; kCS = 0.656; PrCS = 2.88; goto fimTempCS;} if (TempCM>=56.85) {TempCS = 56.85; dCS = 1.016; cpCS = 4184; uCS = 0.000489; kCS = 0.650; PrCS = 3.15; goto fimTempCS;} if (TempCM>=51.85) {TempCS = 51.85; dCS = 1.013; cpCS = 4182; uCS = 0.000528; kCS = 0.645; PrCS = 3.42; goto fimTempCS;} if (TempCM>=46.85) {TempCS = 46.85; dCS = 1.011; cpCS = 4180; uCS = 0.000577; kCS = 0.640; PrCS = 3.77; goto fimTempCS;} if (TempCM>=41.85) {TempCS = 41.85; dCS = 1.009; cpCS = 4179; uCS = 0.000631; kCS = 0.634; PrCS = 4.16; goto fimTempCS;} if (TempCM>=36.85) {TempCS = 36.85; dCS = 1.007; cpCS = 4178; uCS = 0.000695; kCS = 0.628; PrCS = 4.62; goto fimTempCS;} if (TempCM>=31.85) {TempCS = 31.85; dCS = 1.005; cpCS = 4178; uCS = 0.000769; kCS = 0.620; PrCS = 5.20; goto fimTempCS;} if (TempCM>=26.85) {TempCS = 26.85; dCS = 1.003; cpCS = 4179; uCS = 0.000855; kCS = 0.613; PrCS = 5.83; goto fimTempCS;} if (TempCM>=21.85) {TempCS = 21.85; dCS = 1.002; cpCS = 4181; uCS = 0.000959; kCS = 0.606; PrCS = 6.62; goto fimTempCS;} if (TempCM>=16.85) {TempCS = 16.85; dCS = 1.001;
110
cpCS = 4184; uCS = 0.001080; kCS = 0.598; PrCS = 7.56; goto fimTempCS;} if (TempCM>=11.85) {TempCS = 11.85; dCS = 1; cpCS = 4189; uCS = 0.001225; kCS = 0.590; PrCS = 8.81; goto fimTempCS;} if (TempCM>=6.85) {TempCS = 6.85; dCS = 1; cpCS = 4198; uCS = 0.001422; kCS = 0.582; PrCS = 10.26; goto fimTempCS;} if (TempCM>=1.85) {TempCS = 1.85; dCS = 1; cpCS = 4211; uCS = 0.001652; kCS = 0.574; PrCS = 12.22; goto fimTempCS;} if (TempCM>=0) {TempCS = 0; dCS = 1; cpCS = 4217; uCS = 0.001750; kCS = 0.569; PrCS = 12.99;} fimTempCS: //Cálculos de interpolações. dCM = (((TempCM-TempCE)*(dCS-dCE))/(TempCS-TempCE))+dCE; cpCM = (((TempCM-TempCE)*(cpCS-cpCE))/(TempCS-TempCE))+cpCE; uCM = (((TempCM-TempCE)*(uCS-uCE))/(TempCS-TempCE))+uCE; kCM = (((TempCM-TempCE)*(kCS-kCE))/(TempCS-TempCE))+kCE; PrCM = (((TempCM-TempCE)*(PrCS-PrCE))/(TempCS-TempCE))+PrCE;
//Continuação de alguns cálculos. dTempC = TempCSaida-TempCEntrada; mc = q/(cpCM*dTempC); RedTubo = (4*mc)/(N*M_PI*Dtubo*uCM); f = 1/(((0.790*log(RedTubo))-1.64)*((0.790*log(RedTubo))-1.64)); factor001 = (f/8)*(RedTubo-1000)*PrCM; factor002 = 1+12.7*pow(f/8,0.5)*(pow(PrCM,0.666666666667)-1);
//Cálculo para o No. de Nussent (tubo) a partir da faixa do No. de Reynolds. if (RedTubo>=2500) {NudTubo = factor001/factor002;} else {NudTubo = 4.36;} ht = (kCM*NudTubo)/Dtubo;
//Cálculo do No. de Nussent (casco). NudCasco = C*(pow(RedCasco,m))*(pow(PrHM,n))*(pow((PrHM/PrCM),0.25)); hc = (kHM*NudCasco)/Dtubo;
//Agora temos o hc e o ht, logo calcularemos o U. U = 1/((1/ht)+(1/hc));
//Vamos calcular o fator de correção F. R = (TempHEntrada-TempHSaida)/(TempCSaida-TempCEntrada); S = (TempCSaida-TempCEntrada)/(TempHEntrada-TempCEntrada);
111
factor005 = pow(((R*R)+1),0.5); factor003 = (2-(S*(1+R-factor005))); factor004 = (2-(S*(1+R+factor005))); factor006 = log((1-(S*R))/(1-S)); factor007 = (1-R); F = ((factor005*factor006)/(factor007*log(factor003/factor004)));
//E agora calculando o valor de L que representará o comprimento do casco. DeltaTempLM = ((TempHEntrada-TempCSaida)-(TempHSaida-TempCEntrada))/ log((TempHEntrada-TempCSaida)/(TempHSaida-TempCEntrada)); L = (q/(U*M_PI*Dtubo*DeltaTempLM*F*N*Passo));
//Cálculo de dados como: área de troca térmica, diâmentro do casco e outros. Atroca = L*N*Passo*(M_PI*2*(Dtubo/2)); DcascoIN = Dcasco/0.0254; Razao = Atroca/(M_PI*(Dcasco/2)*(Dcasco/2)); VolH2O = (mc)/(dCM*1000); Acalculada = (q/(U*DeltaTempLM)); Excesso = ((Atroca-Acalculada)/Atroca);
//Resultados. printf ("\n\n----------------------------------------------------------------------------------"); printf ("\n CARACATERISTICAS BASICAS DO TROCADOR DE CALOR"); printf ("\n 1. Comprimento do Casco = %lf m",L); printf ("\n 2. Diametro do casco = %lf in",DcascoIN); printf ("\n 3. Diametro do tubo do feixe = %lf m",Dtubo); printf ("\n 4. Quantidade de tubos = %lf ",N); printf ("\n 5. Numero de passes = %lf",Passo); printf ("\n 6. Area de troca termica (calculada) = %lf m2",Acalculada); printf ("\n 7. Area de troca termica (fisica) = %lf m2",Atroca); printf ("\n 8. Excesso do trocador de calor = %lf %%",Excesso); printf ("\n 9. Razao da area de troca termica (fisica) e o volume do trocador = %lf",Razao); printf ("\n 10. Coeficiente global de transferencia de calor = %lf W/m2*K",U); printf ("\n 11. Arranjo dos tubos = Quadrangular"); printf ("\n----------------------------------------------------------------------------------"); printf ("\n RESULTADOS DO OLEO (CASCO)"); printf ("\n 1. Temperatura de entrada = %lf oC",TempHEntrada); printf ("\n 2. Temperatura de saida = %lf oC",TempHSaida); printf ("\n 3. Vazao massica = %lf kg/s",mh); printf ("\n 4. Velocidade do oleo no casco = %lf m/s",V); printf ("\n 5. Velocidade maxima do oleo no casco = %lf m/s",Vmax); printf ("\n 6. Taxa de calor extraido do oleo = %lf KJ/segundo",q); printf ("\n 7. Numero de Reynolds no casco = %lf",RedCasco); printf ("\n 8. Numero de Nussent no casco = %lf",NudCasco); printf ("\n 9. Coeficiente de conveccao no casco = %lf W/m2*K",hc); if (RedCasco>2500) {printf ("\n O escoamento do oleo no casco e: Turbulento");} else {printf ("\n O escoamento do oleo no casco e: Laminar");} printf ("\n----------------------------------------------------------------------------------"); printf ("\n RESULTADOS DA AGUA (TUBOS)"); printf ("\n 1. Temperatura de entrada = %lf oC",TempCEntrada); printf ("\n 2. Temperatura de saida = %lf oC",TempCSaida); printf ("\n 3. Vazao massica = %lf kg/s",mc); printf ("\n 4. Vazao volumetrica da agua = %lf m3/segundo",VolH2O); printf ("\n 5. Numero de Reynolds nos tubos = %lf",RedTubo); printf ("\n 6. Numero de Nussent nos tubos = %lf",NudTubo); printf ("\n 7. Coeficiente de conceccao nos tubos = %lf W/m2*K",ht); if (RedTubo>2500) {printf ("\n O escoamento da agua nos tubos e: Turbulento");} else {printf ("\n O escoamento da agua nos tubos e: Laminar");} printf ("\n----------------------------------------------------------------------------------\n\n"); printf ("\n Pressione 'Enter' para finalizar.");
112
getchar (); return 0; }
Projeto de viga bi-apoiada
#include <stdio.h> #include <stdlib.h> #include <math.h>
//------------------------------------------------------------------------------
main () { //Programa para projetode vigas biapoiadas. int pI, m_viga, pC;
double P, L, CS, Mmax, Vmax, E, Ty, Tadm, Snec, Stab;
int x = 1;
printf ("\n PROGRAMA PARA O PROJETO DE VIGA BI-APOIADAS "); printf ("\n"); printf ("\n"); printf ("\n | carga P"); printf ("\n |"); printf ("\n V"); printf ("\n ====================="); printf ("\n ^ | ^"); printf ("\n |---L/2---|---L/2---|"); printf ("\n\n"); printf ("================================================================");
//Escolha da situação. switch (x) {
//Primeira situacao. case 1: printf ("\n Informe o valor da carga 'P' (N):"); scanf ("%lf",&P); printf ("\n Informe o comprimento da viga (m):"); scanf ("%lf",&L); printf ("\n Informe o coeficiente de seguranca:"); scanf ("%lf",&CS); //Calculos do momento maximo e da forca cortante. Mmax = P*L/4; Vmax = P/2; //Escolha do material com switch dentro de outro switch. int material_1; printf ("\n Escolha o material:"); printf ("\n"); printf ("\n [1] - A-36 [8] - AISI 304"); printf ("\n [2] - AISI-C 1018 [9] - Liga de Aluminio 1100-H12"); printf ("\n [3] - AISI-C 1030 [10] - Liga de Aluminio 2024 T4"); printf ("\n [4] - AISI-C 1040 [11] - Liga de Aluminio 6061 T6"); printf ("\n [5] - AISI-C 1080 [12] - Liga de Aluminio 6063 T6"); printf ("\n [6] - AISI-C 3140 [13] - Liga de Aluminio 2024 T4"); printf ("\n [7] - AISI-C 4340"); printf ("\n Sua opcao e:"); scanf ("%d",&material_1); getchar (); //Escolha do material do perfil através do switch, case e break. //Essa rotina não exerce nenhuma influencia em outra, ele funciona //como um bloco de comandos que serão utilizados pelo programa. switch (material_1) { case 1: // A-36 m_viga = 1;
113
E = 200e9; Ty = 250e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 2: // AISI-C 1018 m_viga = 2; E = 200e9; Ty = 370e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 3: // AISI-C 1030 m_viga = 3; E = 200e9; Ty = 340e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 4: // AISI-C 1040 m_viga = 4; E = 200e9; Ty = 390e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 5: // AISI-C 1080 m_viga = 5; E = 200e9; Ty = 520e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 6: // AISI-C 3140 m_viga = 6; E = 200e9; Ty = 620e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 7: // AISI-C 4340 m_viga = 7; E = 200e9; Ty = 860e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 8: // AISI 304 m_viga = 8; E = 193e9; Ty = 207e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 9: // Liga de Aluminio 1100-H12 m_viga = 9; E = 70e9; Ty = 103e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 10: // Liga de Aluminio 2024 T4 m_viga = 10; E = 74.5e9; Ty = 320e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 11: // Liga de Aluminio 6061 T6 m_viga = 11; E = 69e9; Ty = 275e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 12: // Liga de Aluminio 6063 T6
114
m_viga = 12; E = 69e9; Ty = 145e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; case 13: // Liga de Aluminio 2024 T4 m_viga = 13; E = 72e9; Ty = 500e6; Tadm = Ty/CS; Snec = Mmax*CS/Ty*1E6; break; } //Escolha do perfil da viga. printf ("\n Escolha o perfil para a viga:"); printf ("\n\n [1] - Perfil I"); printf ("\n [2] - Perfil C"); printf ("\n Sua opcao e:"); int perfil; scanf ("%d",&perfil); getchar (); //Mais outro switch, mas agora para a escolha do perfil. //Em forma de bloco também. switch (perfil) {case 1: //Procedimento do cálculo com o perfil I pra situacao 1. printf ("\n Escolha o perfil I de acordo com as dimensoes abaixo:");
printf ("\n Lembrando que Altura x Base e a nomeclatura adotada."); printf ("\n\n [1] - 150x14 [6] - 250x18 [11] - 310x74"); printf ("\n [2] - 150x30 [7] - 250x45 [12] - 310x129"); printf ("\n [3] - 200x22 [8] - 250x80"); printf ("\n [4] - 200x71 [9] - 250x149"); printf ("\n [5] - 200x100 [10] - 310x39"); printf ("\n\n -------------------"); printf ("\n | BASE |"); printf ("\n ------- -------"); printf ("\n | A |"); printf ("\n | L |"); printf ("\n | T |"); printf ("\n | U |"); printf ("\n | R |"); printf ("\n | A |"); printf ("\n ------- -------"); printf ("\n | BASE |"); printf ("\n -------------------"); //Outro switch inserido em switch. É bastante útil em determinadas //circunstância a aplicação de forma composta. printf ("\n A sua escolha e:"); scanf ("%d",&pI); getchar (); switch (pI) {case 1: Stab = 91.2; break; case 2: Stab = 218; break; case 3: Stab = 194; break; case 4: Stab = 709; break; case 5: Stab = 987; break; case 6: Stab = 179; break; case 7: Stab = 535; break; case 8: Stab = 984; break; case 9:
115
Stab = 1840; break; case 10: Stab = 547; break; case 11: Stab = 1060; break; case 12: Stab = 1940; break;}
// Agora com todos os dados estabelecido e as equações calculadas é //possivel imprimir os resultados na tela e descobrir se o perfil //selecionado irá obedecer ao esforço empregado sobre ele. //-----Resultados----- printf ("\n============================================================="); printf ("\n SOLICITACAO E ESPECIFICACAO DA VIGA"); printf ("\n============================================================="); printf ("\n Carga aplicada 'P': %lf N",P); printf ("\n Comprimento da Viga: %lf m",L); printf ("\n Coeficiente de seguranca: %lf",CS); printf ("\n============================================================="); printf ("\n RESULTADOS DOS CALCULOS DA RESPECTIVA VIGA"); printf ("\n============================================================="); printf ("\n Esforco cortane maximo: %lf N",Vmax); printf ("\n Momento fletor maximo: %lf N.m",Mmax); printf ("\n Tensao admissivel: %lf Pa",Tadm); printf ("\n Tensao de escoamento: %lf Pa",Ty); printf ("\n Modulo de elasticidade do material: %lf Pa",E); printf ("\n Modulo de resistencia necessario: %lf mm3",Snec); printf ("\n Modulo de resistencia tabelado: %lf mm3",Stab); printf ("\n"); if (Snec<Stab) {printf ("\n O perfil selecionado suportara o carregamento."); printf ("\n Teste outros perfis para tentar reduzir seus gastos!");} else {printf ("\n O perfil selecionado nao duporta o carregamento."); printf ("\n Escolhe um perfil mais robusto com o Snec superio"); printf ("\n ao desejado.");} getchar (); break; case 2: //Procedimento do cálculo com o perfil C pra situacao 1. printf ("\n Escolha o perfil C de acordo com as dimensoes abaixo:"); printf ("\n Lembrando que Altura x Base e a nomeclatura adotada."); printf ("\n\n [1] - 75x6 [6] - 230x30"); printf ("\n [2] - 100x11 [7] - 250x45"); printf ("\n [3] - 150x19 [8] - 310x45"); printf ("\n [4] - 180x22 [9] - 380x50"); printf ("\n [5] - 200x28 [10] - 380x74"); printf ("\n\n BASE"); printf ("\n ______________"); printf ("\n | |"); printf ("\n | A __________|"); printf ("\n | L |"); printf ("\n | T |"); printf ("\n | U |"); printf ("\n | R |"); printf ("\n | A |_________"); printf ("\n | |"); printf ("\n |_____________|"); printf ("\n"); //Outro switch inserido em switch. É bastante útil em determinadas //circunstância a aplicação de forma composta. printf ("\n A sua escola e:"); scanf ("%d",&pC); getchar (); switch (pC)
{case 1: Stab = 18.1; break; case 2: Stab = 37.5; break; case 3: Stab = 95.3; break;
116
case 4: Stab = 127; break; case 5: Stab = 180; break; case 6: Stab = 221; break; case 7: Stab = 338; break; case 8: Stab = 442; break; case 9: Stab = 688; break; case 10: Stab = 882; break;}
// Agora com todos os dados estabelecido e as equações calculadas é //possivel imprimir os resultados na tela e descobrir se o perfil //selecionado irá obedecer ao esforço empregado sobre ele. //-----Resultados----- printf ("\n============================================================="); printf ("\n SOLICITACAO E ESPECIFICACAO DA VIGA"); printf ("\n============================================================="); printf ("\n Carga aplicada 'P': %lf N",P); printf ("\n Comprimento da Viga: %lf m",L); printf ("\n Coeficiente de seguranca: %lf",CS); printf ("\n============================================================="); printf ("\n RESULTADOS DOS CALCULOS DA RESPECTIVA VIGA"); printf ("\n============================================================="); printf ("\n Esforco cortane maximo: %lf N",Vmax); printf ("\n Momento fletor maximo: %lf N.m",Mmax); printf ("\n Tensao admissivel: %lf Pa",Tadm); printf ("\n Tensao de escoamento: %lf Pa",Ty); printf ("\n Modulo de resistencia necessario: %lf mm3",Snec); printf ("\n Modulo de resistencia tabelado: %lf mm3",Stab); printf ("\n"); if (Snec<Stab) {printf ("\n O perfil selecionado suportara o carregamento."); printf ("\n Teste outros perfis para tentar reduzir seus gastos!"); printf ("\n");} else {printf ("\n O perfil selecionado nao suporta o carregamento."); printf ("\n Escolhe um perfil mais robusto com o Snec superio"); printf ("\n ao desejado.");
printf ("\n");} break;} break; }
getchar (); return 0; }
Projeto de vasos de pressão
#include <stdio.h> #include <stdlib.h> #include <math.h> //--------------------------------------------------- double DegToRad (double x) {return (x*M_PI/180);} //--------------------------------------------------- main () { double R, P, C, Temp, S, E, e, es, PMTA, e_Torri, e_Torri_PMTA, alpha,
117
e_Cone, e_Cone_PMTA, e_Reto, e_Reto_PMTA;
int MC, Grau, Tipo, Tampo;
printf ("\n PROGRAMA PARA O"); printf ("\n DIMENSIONAMENTO DE VASOS DE PRESSAO"); printf ("\n"); printf ("\n Programa para dimensionamento de vasos de pressao"); printf ("\n com costado cilindrico e tampos retos, conicos ou"); printf ("\n torrisfericos e pressao externa."); printf ("\n\n"); printf ("\n 1o. passo - Dimensionamento do costado."); printf ("\n --> Determinacao da espessura da chapa."); printf ("\n\n Entre com o raio interno do cilindro (mm):"); scanf ("%lf",&R); getchar (); printf ("\n Entre com a pressao interna de projeto (Pa):"); scanf ("%lf",&P); getchar (); printf ("\n Entre com sobreespessura para corrosao (mm):"); scanf ("%lf",&C); getchar ();
Temperatura:
printf ("\n Entre com a temperatura de trabalho entre -30 e 500 (oC):"); scanf ("%lf",&Temp); getchar ();
Classe:
printf ("\n Escolha a classe do material:"); printf ("\n"); printf ("\n [1] - (A-285-C)----------->Aco carbono"); printf ("\n [2] - (A-387-11 c 11)----->Aco-liga 1.1/4 Cr -1/2 Mo"); printf ("\n [3] - (A-387-5 c 11)------>Aco-liga 5 Cr - 1/2 Mo"); printf ("\n A escolha e:"); scanf ("%d",&MC); getchar (); if (MC>=4) {printf ("\n Escolha a opcao correta!"); goto Classe;} if (MC<=0) {printf ("\n Escolha a opcao correta!"); goto Classe;}
//Definicao da tensao admissivel do material pela temperatura de trabalho. switch (MC) {case 1: if (Temp<=350) {S = 969;} else if (Temp<=375) {S = 928;} else if (Temp<=400) {S = 847;} else if (Temp<=425) {S = 724;} else if (Temp<=450) {S = 612;} else if (Temp<=475) {S = 490;} else if (Temp>=476) {printf ("\n Nao aplicavel. Entre com outra temperatura!"); goto Temperatura;} break; case 2: if (Temp<=425) {S = 1051;} else if (Temp<=450) {S = 1030;} else if (Temp<=475) {S = 1000;} else if (Temp<=500) {S = 867;} else if (Temp>500) {printf ("\n Nao aplicavel. Entre com outra temperatura!");
118
goto Temperatura;} break; case 3: if (Temp<=325) {S = 959;} else if (Temp<=350) {S = 928;} else if (Temp<=375) {S = 908;} else if (Temp<=400) {S = 857;} else if (Temp<=425) {S = 796;} else if (Temp<=450) {S = 643;} else if (Temp<=475) {S = 469;} else if (Temp<=500) {S = 357;} else if (Temp>500) {printf ("\n Nao aplicavel. Entre com outra temperatura!"); goto Temperatura;} break;}
//Definicao do coeficiente de eficiencia de solda. Grau_inspecao: printf ("\n Escolha o grau de inspecao de soldagem:"); printf ("\n"); printf ("\n [1] - Radiografia Total"); printf ("\n [2] - Radiografia Parcial"); printf ("\n [3] - Nao Radiografada"); printf ("\n A escolha e:"); scanf ("%d",&Grau); getchar (); if (Grau>=4) {printf ("\n Escolha a opcao correta!"); goto Grau_inspecao;} if (Grau<=0) {printf ("\n Escolha a opcao correta!"); goto Grau_inspecao;} switch (Grau) {case 1: Radiografada: printf ("\n Qual o tipo de solda?"); printf ("\n"); printf ("\n [1] - Solda de topo, feita por ambos os lados, ou procedimento equivalente,"); printf ("\n de forma a obter penetracao e fusao totais. (Excluem-se as soldas com"); printf ("\n mata-junta permanente)."); printf ("\n [2] - Solda de topo, feita por um so lado, com mata-junta permanente."); printf ("\n A escolha e:"); scanf ("%d",&Tipo); getchar (); if (Tipo==1) {E = 1;} else if (Tipo==2) {E = 0.9;} else if (Tipo!=1&&2) {printf ("\n Escolha o tipo de solda!"); goto Radiografada;} break;
case 2: Parcial: printf ("\n Qual o tipo de solda?"); printf ("\n"); printf ("\n [1] - Solda de topo, feita por ambos os lados, ou procedimento equivalente,"); printf ("\n de forma a obter penetracao e fusao totais. (Excluem-se as soldas com"); printf ("\n mata-junta permanente)."); printf ("\n [2] - Solda de topo, feita por um so lado, com mata-junta permanente."); printf ("\n A escolha e:");
119
scanf ("%d",&Tipo); getchar (); if (Tipo==1) {E = 0.85;} else if (Tipo==2) {E = 0.80;} else if (Tipo!=1&&2) {printf ("\n Escolha o tipo de solda!"); goto Parcial;} break;
case 3: Nao_Radiografada: printf ("\n Qual o tipo de solda?"); printf ("\n"); printf ("\n [1] - Solda de topo, feita por ambos os lados, ou procedimento equivalente,"); printf ("\n de forma a obter penetracao e fusao totais. (Excluem-se as soldas com"); printf ("\n mata-junta permanente)."); printf ("\n [2] - Solda de topo, feita por um so lado, com mata-junta permanente."); printf ("\n A escolha e:"); scanf ("%d",&Tipo); getchar (); if (Tipo==1) {E = 0.7;} else if (Tipo==2) {E = 0.65;} else if (Tipo!=1&&2) {printf ("\n Escolha o tipo de solda!"); goto Nao_Radiografada;} break;}
//Cálculo do casco cilindrico. e = ((P*R)/((S*E)-(0.6*P)))+C; es = 2.5+(0.002*R)+C; PMTA = ((S*E*e)/(R+(0.6*e))); printf ("\n A espessura do costado e: %lf mm",e); printf ("\n A espessura para estabilidade estrutural: %lf mm",es); printf ("\n Pressao maxima de trabalho admissivel: %lf Pa",PMTA);
//Agora e iniciado a escolha e o calculo da espessura dos tampos printf ("\n"); printf ("\n Escolha o tipo de tampo:"); printf ("\n\n [1] - Torrisferico"); printf ("\n [2] - Conico"); printf ("\n [3] - Plano"); printf ("\n A escolha e:"); scanf ("%d",&Tampo); getchar (); switch (Tampo) {case 1: e_Torri = ((P*R)/((S*E)-(0.1*P)))+C; e_Torri_PMTA = ((S*E*e_Torri)/(R+(0.1*e_Torri))); printf ("\n A espessura do tampo torrisferico e: %lf mm",e_Torri); printf ("\n Pressao maxima de trabalho admissivel no tampo: %lf Pa",e_Torri_PMTA); break;
case 2: printf ("\n Defina o semi-angulo do vertice do cone:"); scanf ("%lf",&alpha); getchar (); e_Cone = ((P*R)/(cos(DegToRad(alpha))*(S*E-(0.6*P))))+C; e_Cone_PMTA = ((S*E*e_Cone*cos(DegToRad(alpha)))/(R+(0.6*e_Cone*cos(DegToRad(alpha)))))+C; printf ("\n A espessura do tampo conico e: %lf mm",e_Cone); printf ("\n Pressao maxima de trabalho admissivel no tampo: %lf Pa",e_Cone_PMTA); break;
case 3: e_Reto = (sqrt((0.33*P)/(S*E)))+C; e_Reto_PMTA = ((127*S)/(2*R)); printf ("\n A espessura do tampo plano e: %lf mm",e_Reto); printf ("\n Pressao maxima de trabalho admissivel no tampo: %lf Pa",e_Reto_PMTA); break;}
120
//Agora basta gerar o relatório de resultados. printf ("\n"); printf ("\n============================================================================="); printf ("\n RELATORIO DE RESULTADOS - '' VASOS DE PRESSAO ''"); printf ("\n============================================================================="); printf ("\n---->> DADOS SOBRE O COSTADO: <<----"); printf ("\n Raio interno em (m): %lf",R); printf ("\n Pressao interna de projeto (Pa): %lf",P); printf ("\n Sobreespesura para corrosao (mm): %lf",C); printf ("\n Temperatura de trabalho (oC): %lf",Temp); printf ("\n Tensao admissivel do material (kgf/cm2): %lf",S); printf ("\n Coeficiente de eficiencia de solda: %lf",E); printf ("\n A espessura do costado e (mm): %lf",e); printf ("\n A espessura para estabilidade estrutural (mm): %lf",es); printf ("\n Pressao maxima de trabalho admissivel (Pa): %lf",PMTA); printf ("\n============================================================================="); printf ("\n---->> DADOS SOBRE OS TAMPOS: <<----"); if (Tampo==1) {printf ("\n Tipo de tampo: Torrisferico"); printf ("\n A espessura do tampo torrisferico e (mm): %lf",e_Torri); printf ("\n Pressao maxima de trabalho admissivel no tampo (Pa): %lf",e_Torri_PMTA);} else if (Tampo==2) {printf ("\n Tipo de tampo: Conico"); printf ("\n A espessura do tampo conico e (mm): %lf",e_Cone); printf ("\n Pressao maxima de trabalho admissivel no tampo (Pa): %lf",e_Cone_PMTA);} else if (Tampo==3) {printf ("\n Tipo de tampo: Plano"); printf ("\n A espessura do tampo plano e (mm): %lf",e_Reto); printf ("\n Pressao maxima de trabalho admissivel no tampo (Pa): %lf",e_Reto_PMTA);} printf ("\n============================================================================="); printf ("\n---->> DADOS GERAIS <<----"); if (MC==1) {printf ("\n Classe do material: A-285-C (Aco carbono)");} if (MC==2) {printf ("\n Classe do material: A-387-11 c 11 (Aco-liga 1.1/4 Cr - 1/2 Mo)");} if (MC==3) {printf ("\n Classe do material: A-387-5 c 11 (Aco-liga 5 Cr - 1/2 Mo)");} if (Grau==1) {printf ("\n Grau da inspecao de soldagem: Radiografia Total");} if (Grau==2) {printf ("\n Grau de inspecao de soldagem: Radiografia Parcial");} if (Grau==3) {printf ("\n Grau de inspecao de soldagem: Nao Radiografada");} if (Tipo==1) {printf ("\n OBSERVACAO:"); printf ("\n Solda de topo, feita por ambos os lados, ou procedimento equivalente,"); printf ("\n de forma a obter penetracao e fusao totais. (Excluem-se as soldas com"); printf ("\n mata-junta permanente).\n\n");} if (Tipo==2) {printf ("\n OBSERVACAO"); printf ("\n Solda de topo, feita por um so lado, com mata-junta permanente.\n\n");} getchar (); return 0; }
121
APÊNDICE C – Ilustrações de execução dos programas abordados
Exemplo referente a Figura 3.1.1
122
Exemplo referente a Figura 3.2.1
123
Exemplo referente a Figura 3.3.1
124
Exemplo referente a Figura 3.3.2
125
Dimensionamento de isolamento térmico em linha de vapor
126
127
128
Projeto de um trocador de calor do tipo casco e tubos (água – óleo)
129
130
131
Projeto de viga bi-apoiada
Projeto de vasos de pressão
