Programação para Engenharias - Softwares Livres PDF

Programação para engenharias utilizando softwares livres

Vr. 1.0 [2008.2]g

1


Vr. 1.0 [2008.2]g

NOTAS DO AUTOR
A apostila busca esclarecer de forma direta para alunos dos cursos de engenharia sobre a
importância da programação no exercício da profissão. Geralmente, os alunos quando estão cursando a disciplina de
programação no seu curso de engenharia não consegue ter uma visão geral de como utilizála e muitas vezes prefere
utilizar um planilha eletrônica.
Um software de planilha eletrônica como o Microsoft Excel®, o antigo Lotus 123, Gnumeric,
Calc do BrOffice e outros. A importância na aprendizagem de uma linguagem de programa influi no momento em
que o aluno necessita realizar o cálculo de um método numérico, por exemplo, método numérico de Newton
Raphson. Alguns métodos numéricos são capazes de serem realizados em planilhas eletrônicas, mas de forma
bastante manual.
As linguagens de programação vem envolvendo cada vez mais o mundo tecnológico. Java, PHP,
MySQL, C#, Delphi, Ruby, C, Python e muitas outras estão presentes em nossos computadores, telefones celulares,
TV digitais, automóveis e etc. O engenheiro do mundo atual necessita entender pelo menos de uma forma básica
sobre programação e tipos de linguagens, da mesma forma que necessita falar três linguas.
A apostila busca facilitar o uso da linguagem de programação C para aplicações em engenharia e
assim o estudante dar o primeiro passo. Da mesma forma que este material é disponibilizado de forma gratuita, se
espera o interesse por parte de outros estudantes, professores e profissionais para colaborar com a expansão do
mesmo.
Vou deixar de blá, blá, blá e espero que gostem!
Rafael de C. Farias
www.engemec.com
2


Vr. 1.0 [2008.2]g

ÍNDICE
1 – INTRODUÇÃO........................................................................................................................................... 4
1.1 – Programação para engenharias?........................................................................................................ 4
1.2 – GPL, livre, gratuito, aberto, customização, trabalho colaborativo................................................. 4
1.3 – Porque e quais softwares utilizar........................................................................................................ 4
2 – PREPARANDO O COMPUTADOR E ESCOLHENDOA LINGUAGEM........................................... 6
2.1 – Configurando o compilador................................................................................................................ 6
2.2 – A linguagem de programação C......................................................................................................... 7
3 – PRIMEIROS PASSOS PARA A PROGRAMAÇÃO EM C................................................................... 8
3.1 – Estrutura de um programa em “C” e o 1º programa....................................................................... 8
3.2 – As 4 operações básicas da matemática............................................................................................... 10
3.3 – Entendendo as funções trigonométricas............................................................................................ 11
4 – DIMENSIONAMENTO DE ISOLAMENTO TÉRMICO EM LINHA DE VAPOR........................... 14
4.1 – Introdução............................................................................................................................................. 14
4.2 – Características do problema............................................................................................................... 14
4.3 – Base teórica........................................................................................................................................... 14
4.4 – Códigofonte comentado passo a passo.............................................................................................. 15
5 – PROJETO DE UM TROCADOR DE CALOR DO TIPO CASCO E TUBOS (ÁGUAÓLEO)......... 22
5.1 – Introdução............................................................................................................................................. 22
5.3 – Base teórica........................................................................................................................................... 23
6 – PROJETO DE VIGA BIAPOIADA......................................................................................................... 35
6.1 – Introdução............................................................................................................................................. 35
6.3 – Base teórica........................................................................................................................................... 35
7 – PROJETO DE VASOS DE PRESSÃO...................................................................................................... 42
7.1 – Introdução............................................................................................................................................. 42
7.3 – Base teórica........................................................................................................................................... 42
REFERÊNCIAS................................................................................................................................................ 49
APÊNDICE A – Fontes de informação para instalação do Ubuntu............................................................. 50
APÊNDICE B – Códigosfonte dos programas abordados........................................................................... 51
3


Vr. 1.0 [2008.2]g

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, e uma forma de contribuição e agradecimento com a
comunidade acadêmica e a sociedade como um todo.
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.
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 LiveCD (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:
4


Vr. 1.0 [2008.2]g

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 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ódigofonte do programa.
5


Vr. 1.0 [2008.2]g

2 PREPARANDO O COMPUTADOR E ESCOLHENDO A LINGUAGEM
2.1 Configurando o compilador
Quando se escreve algum programa, devese 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ódigofonte
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ódigosfonte 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 supersuário. O superusuá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 superusuá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
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:
#aptget install buildessential
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
6


Vr. 1.0 [2008.2]g

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 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.
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.
7


Vr. 1.0 [2008.2]g

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ódigosfonte 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ódigofonte. 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 palavraschaves, 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 3
return 0; |
} |
FIGURA 3.1.1 – Simples códigofonte com divisões explicativas.
O códigofonte 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 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ódigofonte 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ódigofonte, exatamente, para
servir de explicação do mesmo.
Na terceira parte do códigofonte é 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ódigofonte é a escrita do algoritmo.
Existem diversos livros que abordam o estudo de algoritmos e eles servem como um esqueleto do códigofonte. As
disciplinas de programação sempre são iniciadas com o estudo de algoritmos, dessa forma é fácil de se visualizar o
códigofonte. 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ódigofonte 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ódigofonte abaixo:
8


Vr. 1.0 [2008.2]g

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//-----------------------------------
main ()
{
printf ("Nao faz nada!\n");
return 0;
}
FIGURA 3.1.2 – Simples códigofonte sem divisões explicativas.
Agora é necessário que o códigofonte seja salvo com o nome “programa001.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 se encontra o
arquivo criado (programa001.c). O comando de compilação com o GCC (compilador mencionado no início deste
trabalho) é bastante simples. Observe:
$ gcc programa001.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 programa001.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
9


Vr. 1.0 [2008.2]g

chamar “programa001.c”. Na verdade o nome do arquivo pode ser qualquer um, mas a extensão “.c” define que se
trata de um códigofonte 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.
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ódigofonte 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ódigofonte da soma de 2 números.
A “Parte 3” do códigofonte 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ódigofonte no editor de texto puro já
mencionado e salva o arquivo com o nome: programa002.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ódigofonte. Veja a tabela abaixo para entender alguns
padrões que a linguagem “C” utiliza:
TABELA 3.2.1 (página 18 – Apostila Curso de Linguagem C – UFMG)
Tipo Formato para leitura com Intervalo (Início) Intervalo (Fim)
“scanf”
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
10


Vr. 1.0 [2008.2]g

unsigned long int %lu 0 4.294.967.295

float %f 3,4E38 3,4E+38
double %lf 1,7E308 1,7E+308
long double %Lf 3,4E4932 3,4E+4932
Agora, basta entender cada linha do códigofonte 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,7E308 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 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ódigofonte, 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”:
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, devese 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.
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
11


Vr. 1.0 [2008.2]g

elegância do códigofonte 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ódigofonte de programa para conversão de ângulos.
Note que na 11ª linha do códigofonte, 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ódigofonte. Veja o segundo exemplo:
#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));
getchar();
return 0;
}
FIGURA 3.3.2 Códigofonte 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ódigosfonte
em blocos.
Para explicar o que ocorre com a função “DegToRad”, é importante entender a sua estrutura no
trecho na primeira caixa de texto:
É 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:
12


Vr. 1.0 [2008.2]g

O valor de x inserido na função “main” sofre a transformação para radianos 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 programa003.c e programa004.c respectivamente. Veja como seria o comando
de compilação de cada um dos exemplos:
$ gcc programa003.c lm o nomedesejavel
e
$ gcc programa004.c lm o nomedesejavel
Após a compilação dos códigosfonte, a execução do programa será satisfatória e os resultados são
obtidos com 6 casas decimais significativas.
13


Vr. 1.0 [2008.2]g

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.
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.
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
14


Vr. 1.0 [2008.2]g

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:
dT
qr = − k ⋅ (2 ⋅ π ⋅ L) ⋅ (4.3.1)
dr
As resistências térmicas da secção circular que devem ser consideradas são:
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:
Ti − T∞
qr =
ln(r 2 / r1) ln(r 3 / r 2) 1 (4.3.2)
+ +
2 ⋅ π ⋅ L ⋅ kt 2 ⋅ π ⋅ L ⋅ ki 2 ⋅ π ⋅ L ⋅ h ⋅ r 3
E igualando com uma outra forma de escrever a taxa de condução térmica:
Ti − T∞
= m ⋅ cp ⋅ ∆T
ln(r 2 / r1) ln(r 3 / r 2) 1 (4.3.3)
+ +
2 ⋅ π ⋅ L ⋅ kt 2 ⋅ π ⋅ L ⋅ ki 2 ⋅ π ⋅ L ⋅ h ⋅ r 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ódigofonte 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.
4.4 Códigofonte comentado passo a passo
O códigofonte é 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:
15


Vr. 1.0 [2008.2]g

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;
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.
16


Vr. 1.0 [2008.2]g

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");
int KIsolamento;
scanf ("%d",&KIsolamento);
if (KIsolamento == 1)
{KI = 0.025;
Ro = 40;}
{KI = 0.046;
Ro = 130;}
{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ódigofonte. 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 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
17


Vr. 1.0 [2008.2]g

expressão “Eiso = R3R2”. 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” 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:
18


Vr. 1.0 [2008.2]g

if (x==2)
{
A declaração de todas as variáveis é necessária, pois a condição “if” trata o códigofonte 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:
printf ("\n Especifique a diametro externo do tubo (m): ");

scanf ("%lf",&R2);
scanf ("%lf",&e);
R1 = R2-e;
int KTubo;
if (KTubo == 1)
if (KTubo == 2)
if (KTubo == 3)
int KIsolamento;
{KI = 0.025;
Ro = 40;}
{KI = 0.046;
Ro = 130;}
{KI = 0.037;
Ro = 60;}
H = 30;
scanf ("%lf",&L);
VAZAO = vazao/3600;
TI = T_int+273.15;
TA = T_ext+273.15;
Teta = TI/1000;
C0 = 1.79;
C1 = 0.107*Teta;
19


Vr. 1.0 [2008.2]g

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. 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;
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");
}
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");
}
getchar();
getchar();
goto inicio;
}
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();
20


Vr. 1.0 [2008.2]g

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.
21


Vr. 1.0 [2008.2]g

5 PROJETO DE UM TROCADOR DE CALOR DO TIPO
CASCO 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 cascotubo.
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.
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 cascotubo 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 cascotubo 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.
22


Vr. 1.0 [2008.2]g

Com alguns dos parâmetros já descritos, fica mais fácil de se elaborar a rotina 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.
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 devese 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 i , c T o , c 
T m ,c = (5.3.1)
2
e
T i ,t T o , t 
T m ,t = (5.3.2)
2
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 tratase 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:
w
v c= (5.3.4)
Ab
O primeiro termo da equação é a velocidade do óleo no casco em m/s, o terceiro termo que é a
23


Vr. 1.0 [2008.2]g

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:
P
v max = ⋅v (5.3.5)
 P−D t  c
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 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:
 c⋅v max⋅D t 
R e D ,c = (5.3.6)
c
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:
0,25
m
Nu D , c =C⋅ R e D  ⋅ Pr  ⋅
Pr
n
Pr s   (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,36
100 – 1000 0,50 0,36
103 – 2x105 0,63 0,36
2x105 – 2x106 0,80 0,40
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 15
C 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:
24


Vr. 1.0 [2008.2]g

NuD⋅k c
h c= (5.3.8)
Dt
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:
q
ṁ= (5.3.9)
c p ,t⋅T o−T i t 
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:
4⋅ṁt
R e D ,t = (5.3.10)
 N t⋅⋅D t⋅
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:
Nu D ,t =
 
f
8
⋅ R e D ,t −1000⋅Pr t
(5.3.11)
 
1 /2
112,7⋅
f
8   ⋅ Pr 2 /3
t −1
Sendo o valor de “f” calculado pela fórmula:
−2
f =0,790⋅ln  R e D ,t −1,64  (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:
Nu D ,t⋅k t
ht= (5.3.13)
Dt
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:
−1
1 1
U= 

hc ht  (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:
25


Vr. 1.0 [2008.2]g

q
L t= (5.3.15)
Passo⋅N t⋅U⋅⋅Dt⋅F cr⋅ T lm ,CF 
Onde o “Fcr” é calculado pela equação:
1−S⋅R
 R 210,5⋅ln
1−S 
F cr = (5.3.16)
2−S ⋅ R1− R210,5 
1−R⋅ln
2−S ⋅ R1 R210,5 
E os valores de R e S podem ser encontrados por:
T o , t−T i ,t 
S= (5.3.17)
T i ,c −T i ,t 
e
T i , c−T o ,c 
R= (5.3.18)
T o , t−T i ,t 
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ódigofonte do programa para o cálculo do comprimento do
feixe tubular.
O códigofonte abaixo se apresenta de forma resumida, pois muitos detalhes de repetição foram
substituídos por linhas pontilhadas. Dessa forma, o códigofonte para entendimento não fica comprometido e nem
extenso demais.
O códigofonte 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:
26


Vr. 1.0 [2008.2]g

//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. 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 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ódigofonte 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ódigofonte a linha com a palavra
“fimTempHE:”. A caixa 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ódigofonte 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;
27


Vr. 1.0 [2008.2]g

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 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;
28


Vr. 1.0 [2008.2]g

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ódigofonte 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;
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 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;}
29


Vr. 1.0 [2008.2]g

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 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 22 - 22 tubos, 4 passos, 8 in de casco");
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ódigofonte, é 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”:
//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");
scanf ("%d",&w);
if (w==1)
{Bocal = 0.0254;}
if (w==2)
{Bocal = 0.0381;}
if (w==3)
{Bocal = 0.0508;}
30


Vr. 1.0 [2008.2]g

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;}
{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. Efetuase 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:
//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;

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;
31


Vr. 1.0 [2008.2]g

uCE = 0.000306;
kCE = 0.677;
PrCE = 1.91;
goto fimTempCE;}
fimTempCE:

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>=0)
{TempCS = 0;
dCS = 1;
cpCS = 4217;
uCS = 0.001750;
kCS = 0.569;
PrCS = 12.99;}
fimTempCS:
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 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:
32


Vr. 1.0 [2008.2]g

//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ódigofonte.
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ódigofonte 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);
33


Vr. 1.0 [2008.2]g

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ódigofonte, é 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);
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.
34


Vr. 1.0 [2008.2]g

6 PROJETO DE VIGA BIAPOIADA
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çosliga, 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.
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:
● Aço carbono A36;
● 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.
6.3 Base teórica
35


Vr. 1.0 [2008.2]g

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:
 P⋅L 
M max = (6.3.1)
4
e
P
V max = (6.3.2)
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 é:
I
Snec= (6.3.3)
c
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
= (6.3.4)
I
Agora, realizando as devidas substituições se obtém:
M
Snec= (6.3.5)
 adm
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:
 mat
fs= (6.3.6)
 adm
Logo, o valor de “Snec” do perfil selecionado deve ser de acordo com a equação:
M⋅fs
Snec= (6.3.7)
 mat
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 tab Snec (6.3.8)
Com as equações estabelecidas, pode ser iniciado o processo de elaboração do códigofonte.
6.4 Códigofonte comentado passo à passo
substituídos por linhas pontilhadas. Dessa forma, para entendimento não fica comprometido e nem extenso demais.
36


Vr. 1.0 [2008.2]g

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ódigofonte 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:
switch ( ) Para o valor de( )
{case 1: {se for 1:
bloco de comandos; executa essa seqüência de comandos;
break; saída da rotina de seleção;
case n + 1: se for n + 1:
bloco de comandos; executa essa seqüência de comandos;
............. .............
........ ........
..... .....
case n: se for n:
bloco de comandos; execute essa seqüência de comandos;
FIGURA 6.4.1 – Estrutura das rotina com switchcasebreak.
A apresentação da forma que se deve utilizar a rotina de seleção que envolve “switchcasebreak” é
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;
37


Vr. 1.0 [2008.2]g

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 [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ódigofonte é 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. Efetuase 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;
break;
..........................
................
........
...
case 13: // Liga de Aluminio 2024 T4
E = 72e9;
Ty = 500e6;
Tadm = Ty/CS;
break;
}
O bloco de códigofonte 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 “ifelseif”. A vantagem da rotina com
o “switchcasebreak” é 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ódigofonte. Vale ressaltar
que ao final dos comentários do códigofonte terá a estrutura do programa de forma simplificada. O bloco de
códigofonte seguinte é relacionado à opção de seleção do perfil da viga. Um outro detalhe que pode ser percebido é
38


Vr. 1.0 [2008.2]g

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");
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;
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\n [1] - 75x6 [6] - 230x30");
printf ("\n [2] - 100x11 [7] - 250x45");
printf ("\n [3] - 150x19 [8] - 310x45");
printf ("\n [4] - 180x22 [9] - 380x50");
39


Vr. 1.0 [2008.2]g

printf ("\n [5] - 200x28 [10] - 380x74");

........................
................
.........
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 10:
Stab = 882;
break;}
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n");
if (Snec<Stab)
printf ("\n Teste outros perfis para tentar reduzir seus gastos!");
printf ("\n");}
else
printf ("\n ao desejado.");
printf ("\n");}
break;}
break;
}
getchar ();
return 0;
}
Para uma maior compreensão do códigofonte como um todo, é necessário ver a descrição do
mesmo de acordo com a estrutura a seguir. Observe:
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.......
40


Vr. 1.0 [2008.2]g

break ;}
break ;}
break ;}
getchar ( ) ;
return 0 ;
}
FIGURA 6.4.1 – Estrutura do códigofonte aplicado no Cap. 6
Com estrutura descrita acima, é fácil perceber o início da divisão do códigofonte 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ódigofonte 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 “switchcasebreak”. No final de todas as rotinas de
escolha, o programa é finalizado com um simples “return 0 ;”.
41


Vr. 1.0 [2008.2]g

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.
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 – UCS23, 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.
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:
P⋅R
e= C (7.3.1)
 S⋅E −0,6⋅P 
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:
e s= 2 , 50 , 0 0 2⋅RC (7.3.2)
42


Vr. 1.0 [2008.2]g

Outra informação de extrema importância é a pressão máxima de trabalho admissível conhecida
como PMTA. Ela é calculada pela equação:
S⋅E⋅e
PMTA= (7.3.3)
 R0,6⋅e
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ódigofonte apresenta 3 possibilidades de escolha. Tampo plano, semielí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 semielíptico e a equação para a pressão máxima de trabalho
admissível:
P⋅R
e te= C (7.3.4)
 S⋅E−0,1⋅P 
e
S⋅E⋅e te
PMTAte= (7.3.5)
 R0,1⋅ete 
Veja a forma de um tampo semielíptico:
FIGURA 7.3.1 – Tampo semielíptico.
As equações para o tampo cônico são:
P⋅R
e tc= C (7.3.6)
cos ⋅S⋅E−0,6⋅P
e
S⋅E⋅etc⋅cos 
PMTAtc= C (7.3.7)
 R0 , 6⋅e tc⋅cos 
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:
e tp =
e
 N⋅P
 S⋅E 
C (7.3.8)
127⋅S
PMTAtp= (7.3.9)
2⋅R
43


Vr. 1.0 [2008.2]g

Observe a forma de um tampo plano:
FIGURA 7.3.3 – Tampo plano.
substituídos por linhas pontilhadas. Dessa forma, o códigofonte para entendimento não fica comprometido e nem
extenso demais.
O códigofonte 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 “switchcase
break”, “ifelseif”, criação de funções e outras bastante interessantes. O cabeçalho padrão foi retirado, pois o
códigofonte completo e sem cortes se encontra no Apêndice B.

//---------------------------------------------------
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ódigofonte 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);
getchar ();
printf ("\n Entre com sobreespessura para corrosao (mm):");
scanf ("%lf",&C);
getchar ();
O trecho de códigofonte 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);
44


Vr. 1.0 [2008.2]g

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)
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:”.
//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 “switchcasebreak” e “ifelse
if” aninhadas. O trecho não apresenta todos os “case” porque não é interessante de ser mostrado nesse momento,
pois todo o códigofonte se encontra no Apêndice B. Vale salientar nesse momento que para cada “ifelseif” 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");
45


Vr. 1.0 [2008.2]g


scanf ("%d",&Grau);
getchar ();
if (Grau>=4)
goto Grau_inspecao;}
if (Grau<=0)
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 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 “switchcasebreak” é 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 “switchcasebreak” 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 “ifelseif”. É 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.");
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ódigofonte 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);
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:
46


Vr. 1.0 [2008.2]g

//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");
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");
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);}
47


Vr. 1.0 [2008.2]g

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;
}
48


Vr. 1.0 [2008.2]g

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 Biapoiadas – 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.
49


Vr. 1.0 [2008.2]g

APÊNDICE A – Fontes de informação para instalação do Ubuntu
http://img01.link.estadao.com.br/multimidia/infografico/InstalarLinux.pdf
http://brlinux.org/linux/tutorial_de_instalao_do_ubuntu_6.06
http://www.gnx.com.br/apostilas/apostilaUbuntuInstalacaoGPL.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/ubuntuparticoes/272726/
http://www.forumpcs.com.br/viewtopic.php?t=128477
http://wiki.meyer.eti.br/_media/howto/ubuntufeistyinstall.pdf
http://ubuntuforumbr.org/
http://ubuntuforums.org/
http://www.linuxforums.org/forum/ubuntuhelp/
50


Vr. 1.0 [2008.2]g

APÊNDICE B – Códigosfonte 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;
}
#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;
getchar ();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//-----------------------------------
main ()
{
double x, y;
scanf("%lf",&x);
getchar();
y = sin((x*M_PI)/180);
getchar();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//-----------------------------------
//-----------------------------------
main ()
51


Vr. 1.0 [2008.2]g

{
double x, y;
scanf("%lf",&x);
getchar();
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;
scanf ("%lf",&R2);
scanf ("%lf",&e);
R1 = R2-e;
int KTubo;
if (KTubo == 1)
if (KTubo == 2)
if (KTubo == 3)
int KIsolamento;
{KI = 0.025;
Ro = 40;}
{KI = 0.046;
Ro = 130;}
{KI = 0.037;
Ro = 60;}
H = 30; //Coeficiente de convecção externa.
scanf ("%lf",&L);
52


Vr. 1.0 [2008.2]g


VAZAO = vazao/3600;
TI = T_int+273.15;
TA = T_ext+273.15;
Teta = TI/1000;
C0 = 1.79;
C1 = 0.107*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);
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");
}
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");
}
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;
scanf ("%lf",&R2);
scanf ("%lf",&e);
R1 = R2-e;
53


Vr. 1.0 [2008.2]g


int KTubo;
if (KTubo == 1)
if (KTubo == 2)
if (KTubo == 3)
int KIsolamento;
{KI = 0.025;
Ro = 40;}
{KI = 0.046;
Ro = 130;}
{KI = 0.037;
Ro = 60;}
H = 30;
scanf ("%lf",&L);
VAZAO = vazao/3600;
TI = T_int+273.15;
TA = T_ext+273.15;
Teta = TI/1000;
C0 = 1.79;
C1 = 0.107*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;
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);
if (RC<R1)
{
54


Vr. 1.0 [2008.2]g

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");
}
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");
}
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 2 - A temperatura da agua deve estar na faixa de (0 <-> 91.85) oC,");
printf ("\n 3 - A agua entra pelo feixe de tubos e o oleo pelo casco, isso se deve,");
55


Vr. 1.0 [2008.2]g

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;

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;
PrHE = 1965;
56


Vr. 1.0 [2008.2]g

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;
57


Vr. 1.0 [2008.2]g

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:

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;
58


Vr. 1.0 [2008.2]g

aHS = 0.0000000695;
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;
59


Vr. 1.0 [2008.2]g

dHS = 871.8;
cpHS = 1993;
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:
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 ();
60


Vr. 1.0 [2008.2]g

//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;
//Escolha do diâmetro do tubo.

printf ("\n Escolha o diametro do tubo do feixe: ");
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 2 - 16 tubos, 1 passo, 3.5 in de casco");
printf ("\n 10 - 8 tubos, 2 passos, 3.5 in de casco");
printf ("\n 18 - 4 tubos, 4 passos, 3,5 in de casco");
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;
61


Vr. 1.0 [2008.2]g

C = 0.95;
Passo = 1;}
if (y==5)
{N = 52;
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)
62


Vr. 1.0 [2008.2]g

{N = 3;
Dcasco = 3*0.0254;
Nf = 4;
C = 0.90;
Passo = 4;}
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 2 - Bocal de 1.5 in");
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;}
{m = 0.5;
63


Vr. 1.0 [2008.2]g

n = 0.36;}
{m = 0.63;
n = 0.36;}
else if(RedCasco<=2000000)
{m = 0.8;
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;

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;
64


Vr. 1.0 [2008.2]g

uCE = 0.000855;
kCE = 0.613;
PrCE = 5.83;
goto fimTempCE;}
if (TempCM<=31.85)
{TempCE = 31.85;
dCE = 1.005;
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;
65


Vr. 1.0 [2008.2]g

goto fimTempCE;}
if (TempCM<=76.85)
{TempCE = 76.85;
dCE = 1.027;
cpCE = 4195;
uCE = 0.000365;
kCE = 0.668;
PrCE = 2.29;
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:

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;
66


Vr. 1.0 [2008.2]g

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;
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)
67


Vr. 1.0 [2008.2]g

{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;
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:
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).
68


Vr. 1.0 [2008.2]g

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);
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);
69


Vr. 1.0 [2008.2]g

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;
}
Projeto de viga biapoiada
#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 [7] - AISI-C 4340");
70


Vr. 1.0 [2008.2]g


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;
E = 200e9;
Ty = 250e6;
Tadm = Ty/CS;
break;
m_viga = 2;
E = 200e9;
Ty = 370e6;
Tadm = Ty/CS;
break;
m_viga = 3;
E = 200e9;
Ty = 340e6;
Tadm = Ty/CS;
break;
m_viga = 4;
E = 200e9;
Ty = 390e6;
Tadm = Ty/CS;
break;
m_viga = 5;
E = 200e9;
Ty = 520e6;
Tadm = Ty/CS;
break;
m_viga = 6;
E = 200e9;
Ty = 620e6;
Tadm = Ty/CS;
break;
m_viga = 7;
E = 200e9;
Ty = 860e6;
Tadm = Ty/CS;
break;
case 8: // AISI 304
m_viga = 8;
E = 193e9;
Ty = 207e6;
Tadm = Ty/CS;
break;
case 9: // Liga de Aluminio 1100-H12
m_viga = 9;
E = 70e9;
Ty = 103e6;
Tadm = Ty/CS;
break;
m_viga = 10;
E = 74.5e9;
Ty = 320e6;
71


Vr. 1.0 [2008.2]g

Tadm = Ty/CS;
break;
m_viga = 11;
E = 69e9;
Ty = 275e6;
Tadm = Ty/CS;
break;
m_viga = 12;
E = 69e9;
Ty = 145e6;
Tadm = Ty/CS;
break;
m_viga = 13;
E = 72e9;
Ty = 500e6;
Tadm = Ty/CS;
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");
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\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:
72


Vr. 1.0 [2008.2]g

Stab = 987;
break;
case 6:
Stab = 179;
break;
case 7:
Stab = 535;
break;
case 8:
Stab = 984;
break;
case 9:
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.
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n Modulo de elasticidade do material: %lf Pa",E);
printf ("\n");
if (Snec<Stab)
printf ("\n Teste outros perfis para tentar reduzir seus gastos!");}
else
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\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.
73


Vr. 1.0 [2008.2]g

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;
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.
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n=============================================================");
printf ("\n");
if (Snec<Stab)
printf ("\n Teste outros perfis para tentar reduzir seus gastos!");
printf ("\n");}
else
{printf ("\n O perfil selecionado nao suporta o carregamento.");
printf ("\n ao desejado.");
printf ("\n");}
break;}
break;
}
getchar ();
return 0;
}
Projeto de vasos de pressão
74


Vr. 1.0 [2008.2]g

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
//---------------------------------------------------
//---------------------------------------------------
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;
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");
scanf ("%d",&MC);
getchar ();
if (MC>=4)
goto Classe;}
if (MC<=0)
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)
goto Temperatura;}
75


Vr. 1.0 [2008.2]g

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)
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)
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");
scanf ("%d",&Grau);
getchar ();
if (Grau>=4)
if (Grau<=0)
switch (Grau)
{case 1:
Radiografada:
printf ("\n");
equivalente,");
com");
scanf ("%d",&Tipo);
getchar ();
if (Tipo==1)
{E = 1;}
else if (Tipo==2)
{E = 0.9;}
goto Radiografada;}
break;
76


Vr. 1.0 [2008.2]g

case 2:
Parcial:
printf ("\n");
equivalente,");
com");
scanf ("%d",&Tipo);
getchar ();
if (Tipo==1)
{E = 0.85;}
else if (Tipo==2)
{E = 0.80;}
goto Parcial;}
break;
case 3:
Nao_Radiografada:
printf ("\n");
equivalente,");
com");
scanf ("%d",&Tipo);
getchar ();
if (Tipo==1)
{E = 0.7;}
else if (Tipo==2)
{E = 0.65;}
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");
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)))))
77


Vr. 1.0 [2008.2]g

+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;}
//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;
}
78

Programação para Engenharias - Softwares Livres PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programação para Engenharias - Softwares Livres PDF

Enviado por

Direitos autorais:

Formatos disponíveis

O trabalho realizado utilizou um SO (Sistema Operacional) totalmente livre e gratuito sob a

O código­fonte foi dividido em 3 partes. A primeira se refere aos arquivos de biblioteca

unsigned long int %lu 0 4.294.967.295

double R1, R2, R3, KI, KT, H, L, VAZAO, Cp, e, vazao,

printf ("\n Espeficique a diametro externo do tubo (m): ");

printf ("\n Escolha o material do tubo:\n");

printf ("\n Escolha o material do isolamento termico:\n");

H = 30; //Coeficiente de convecção externa.

printf ("\n Espessura do isolamento recomendada ========================> %5.4lf (m)",

printf ("\n Especifique a diametro externo do tubo (m): ");

printf (" Espessura do isolamento desejado (m):");

As possibilidades para alteração e melhorias do programa apresentado nesse capítulo são

q= ṁ⋅c p⋅T i , c −T o ,c  (5.3.3)

Encontrado o valor do coeficiente de convecção do casco, o próximo passo é encontrar o

Agora é possível se calcular o coeficiente global de transferência de calor que servirá para o

Após a declaração de todas as variáveis do programa, é interessante fazer uma figura

//Mensagem de informação do programa.

//Entrada dos valores da temperatura de entrada e saída do óleo.

Após a declaração das temperaturas de entrada e saída do óleo de motor, é necessário que o

//Busca de TempHM pelos valores menores e maiores.

//1a. parte da interpolação.

//Continuação da 2a. parte para interpolação.

//Entrada do valor da vazão do óleo.

//Cálculos a partir da vazão do óleo fornecida.

//Escolha do diâmetro do tubo.

//Escolha a configuração do trocador nos parâmetros abaixo.

//Escolha o bocal de entrada do óleo.

Com os dados já calculados, é possível dar continuidade no procedimento de resolução do

//Calculos complementares como: No. de Reynolds, área da secção do bocal e etc.

//Dados de temperatura da água de entrada e saída desejadas.

//Busca de TempCM pelos valores menores e maiores.

//1a. parte da interpolação.

//Continuação da 2a. parte para interpolação.

//Continuação de alguns cálculos.

//Cálculo para o No. de Nussent (tubo) a partir da faixa do No. de Reynolds.

//Cálculo do No. de Nussent (casco).

//Agora temos o hc e o ht, logo calcularemos o U.

//Vamos calcular o fator de correção F.

A separação da Equação 5.3.16 em termos como “factor003”, “factor004”, “factor005”,

//E agora calculando o valor de L que representará o comprimento do casco.

//Cálculo de dados como: área de troca térmica, diâmentro do casco e outros.

Snec tab Snec (6.3.8)

int pI, m_viga, pC;

double P, L, CS, Mmax, Vmax, E, Ty, Tadm, Snec, Stab;

printf ("\n PROGRAMA PARA O PROJETO DE VIGA BI-APOIADAS ");

O bloco de código­fonte apresentado acima, é referente à escolha do material. Outra rotina

//Escolha do perfil da viga.

printf ("\n [5] - 200x28 [10] - 380x74");

e s= 2 , 50 , 0 0 2⋅RC (7.3.2)

double DegToRad (double x)

int MC, Grau, Tipo, Tampo;

O bloco de código­fonte acima apresenta como início do programa a criação da função

printf ("\n PROGRAMA PARA O");

printf ("\n Escolha a classe do material:");

//Definicao da tensao admissivel do material pela temperatura de trabalho.

//Definicao do coeficiente de eficiencia de solda.

printf ("\n A escolha e:");

//Calculo do casco cilindrico.

//Agora e iniciado a escolha e o calculo da espessura dos tampos

//Agora basta gerar o relatório de resultados.

printf (" Informe a vazao massica do vapor (kg/s): ");

printf (" 1 - Tubo de aco carbono ANSI 1010.\n");

//Mensagem de informação do programa.

O códigofonte foi dividido em 3 partes. A primeira se refere aos arquivos de biblioteca

O bloco de códigofonte apresentado acima, é referente à escolha do material. Outra rotina

O bloco de códigofonte acima apresenta como início do programa a criação da função