A1 - ATPS ALGORITMO 2º SEMESTRE

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

(
3
)ATPS: Relatório 1 - Conceitos Fundamentais de Programação
FACULDADE ANHANGUERA DE SÃO JOSÉ DOS CAMPOS
CURSO DE BACHARELADO EM ENGENHARIA ELÉTRICA E ENGENHARIA AUTOMAÇÃO
Adriano Tavares Amorim
RA 8635253611 | Eng. Eletrica
adriatam80@gmail.com
Alexandre dos Reis Soares
RA 8407151610 | Eng. Eletrica
ale.ars@hotmail.com
Carlos Eduardo Avanzi
RA 8469219772 | Eng. Eletrica
carlos.eavanzi@gmail.com
Deiviti Costa Silva
RA 9902015540 | Eng. Automação
owner@focustudios.net
Elaine Cristine de Oliveira
RA 1299279283 | Eng. Eletrica
lana.jhs@gmail.com
Elton Clayton de Paula
RA 8638276818 | Eng. Eletrica
Clayton12325@gmail.com
Jonathan Leonardo Nascimento
RA 8635260737 | Eng. Eletrica
jln26041995@gmail.com
Raianne Borges
RA 8490224157 | Eng. Automação
raianne.costa.borges@gmail.com
Professor orientador:
Gledson
Anhanguera Educacional
ATIVIDADE PRÁTICA SUPERVISIONADA DE Algoritimo e programação - ATPS
Elaborar um software para aprimorar o corte das bobinas (jumbo), considerando que as larguras das bobinas podem variar, bem como a quantidade solicitada pelos clientes.
Resumo
O objetivo desta ATPS é demonstrarde forma prática onde e como poderiamos usar os conceitos de algoritimo e programação aprendidos no curso de bacharelado em egenhariaco elétrica e engenharia de automação e controle. A utilização da forma humana de entedimento da programação o algoratimo bem como a sua conversão para a linguagem de programação em C++.
Palavras-Chave: algoritmo, C++, programação, software.
A evolução de um pensamento, inicia-se quando desistimos de nossas mentes carregadas de vícios e costumes que nos prendem. Somente quando postulamos pelo novo e investimos no que ainda não alcançamos tornamos-nos donos de um pensamento inovador. (SILVA. Deiviti C. 2014).
 (
2
)ATPS: cálclos de grandesa física (medições, aceleração e equações de movimento
ATPS: Desenvolvimento de circuitos eletrônicos de potência – Bacharelado em Engenharia Elétrica – Turma 8ª EES
 (
2
)ATPS: Relatório 1 - Conceitos Fundamentais de Programação
ATPS: Algoritimo e Programação – Bacharelado em Engenharia Elétrica e Engenharia de Automação e Controle – 2º semestre
 (
1
1
1
)
SUMÁRIO
INTRODUÇÃO...............................................................................................................	03
1 ETAPA 1 ......................................................................................................................	04
1.1 PASSO 1 e 2...............................................................................................................	04
1.2 Pseudo Linguagem......................................................................................................	05
1.3 Tipos primitivos para representação de dados e variáveis..........................................	05
1.4 Operadores aritiméticos...............................................................................................	06
1.5 Características do ambiente de linguagem C...............................................................	06
1.6 PASSO 3 ...................................................................................................................	07
1.6.1 Função matemática..................................................................................................	07
1.6.2 Linguagem C............................................................................................................	08
1.6.3 Variáveis que armazenaram informações.................................................................	08
2 ETAPA 2......................................................................................................................	09
2.1 PASSO 1 e 2..............................................................................................................	09
2.2 Aplicação de conceitos de estrutura..............................................................................	09
2.3 Desenvolvimento dos laços de repetição........................................................................	09
2.4 Desenvolvimento em C...............................................................................................	10
introdução
Este trabalho tem como finalidade atender a AtPS (Atividade Pratica Supervisionada) do curso de bacharelado em engenharia elétrica e egenharia de automação e controle. O objetivo que foi passado, foi de desenvolver um software que otimizasse o corte das bobinas de papeis e celulose, melhorando assim a utilização e diminuindo o desperdício, bem como visualizar a viabilidade de atendimentod e um cliente ou não pela empresa.
Colocar em pratica o conhecimento adquirido nas aulas-téoricas e aulas-práticas (laboratório), criando um algoritimo capaz de demostrar em linguagem humana a efetiva utilização do software e através do mesmo a escrita do programa em linguagem C++ utilizando o copilador Dev c++.
Para iniciar o trabalho foram feita leituras dos materiais dispostos no manual desta atps e feito um descrivo do entendimento da parte teórica do mesmo, descrevendo a forma interpretada por nós do grupo MAD-TANDO sobre os conceitos de: 
- noções de algoritimo;
- pseudo linguagem;
- estrutuda de um programa;
- tipos primitivos para representação de dados e variáveis;
- operadores aritméticos, lógicos e relacionais e;
- características do ambiente de desenvolvimento C.
ETAPA 1
1.1 PASSO 1 E 2
Efetuando a leitura dos matériais indicados encontramos uma definição bem completa para o significado de algoritimo, no texto introdução ao algoritmo disponibilizado pelo manual desta atps defini logo em sua primeira página o mesmo como... Um conjunto de ações com propriedades especiais e específicas e com algumas estruturas padrões para controlar a ordem na qual as ações são realizadas.
	Pode-ser ver com a definição do paragrafo acima que o algoritimo em sí não pode ser dito como um programa de informática ou como uma simples base para a criação de um software, em outras palavras podemos concluir que o algoritimo é como realizamos tudo, sim, parece um exagero? Mas não é, todas as vezes que programamos algo que postulamos realizar, inconcientemente nós realizamos um algoritimo, ao sair para um passeio, a verificação se possuimos recursos suficientes, se temos o local adequado ou até mesmo se estamos com a companhia que gostariamos nesta viegem, nós realizamos um pequeno ou grande projeto em nossa mente, idealizando desta forma mesmo sem saber um algoritimo.
Interessante isto não, vejamos outro exemplo: Todos os dias um pai de família qualquer levanta as 4:00 horas da manhã, toma seu banho, escova seus dentes, toma seu café e sai ao trabalho, bate cartão as 8:00 horas em ponto, trabalha até as 12:00 horas, volta as 13:00 horas e trabalha até as 17:30, neste exato momento ele bate novamente o seu cartão, e vai para sua residencia onde encontra com sua esposa filhos, janta descança um pouco se distraindo com os filhos e depois vai ao sono e por ai vai, paremos para analizar o contexto da narrativa acima e iremos notar algumas características comuns que são vistas sempre que pensarmos em rotinas, sempre iremos chegar a uma séria de idéias definidas que seguem regras firmes passo-a-passo para gerar um resultado, podemos dizer que esta é a propriedade dos algoritimos então:
· Sequencia finita de passos;
· Sequencia ordenada de ações;
· Ação simples e definidas.
1.2 PSEUDO LINGUAGEM
Na linguagem computacional as ações precisam de uma linguagem de modo que as ações representem comandos que possam ser entendidos e realizados pelo computado, a pseudo linguagem utiliza-se de um meio termo entre a linguagem humana e a linguagem de programação, desta forma escrito o algorítimo de um modo que possamos entender e elaborar um programa antes de o executar própriamente dito com a finalidade de avaliar a real necessidade do que o programa precisa fazer, eliminando desta forma a perda de tempo e erros na programalçao. O computador possui um conjunto limitado de instruções e o programa deve ser expresso com
estas instruções.
Para aproximar a linguagem computacional da linguagem natural, usaremos o PORTUGOL.
Além da simplicidade, vai permitir mesclar regras e estruturas, tornando possível discriminar detalhes para depois modelar na linguagem executável pelo computador.
Uma linguagem simplificada, onde não se preocupa nos detalhes da linguagem mas no problemas em si, é importante ressaltar que em linguagem de programação precisamos fixar sua sintaxe[footnoteRef:2] e sua semântica[footnoteRef:3]; [2: como escrever os comandos e seus componentes (tipos, variáveis, etc.)] [3: o significado de cada comando e conceito.] 
1.3 TIPOS PRIMITIVOS PARA REPRESENTAÇÃO DE DADOS E VARIÁVEIS.
	Dados são os valores e operações que uma variável pode conter ou executar.
	Variáveis são componentes das linguagens de programação, que identificam as informações que estão sendo manipulados pelos programas. É a variável que armazena um tipo especifico de conteúdo.
	São os comandos básicos que efetuam tarefas essenciais para a operação dos computadores. Onde temos os dispositivos de entrada e saída, a sintaxe que é o modo como o programa deve ser escrito.
1.4. OPERADORES ARITMÉTICOS, LÓGICOS E RELACIONAIS
Os Aritméticos são utilizados para expressar equações matemáticas. Ex.: Adição (+), Subtração (-), Multiplicação (*), entre outros.
Os lógicos são usados para combinar expressões relacionais. Devolvem como resultado valores lógicos. Ex.: VERDADEIRO OU FALSO, Conjunção, Disjunção, entre outros.
1.5 CARACTERÍSTICAS DO AMBIENTE DE DESENVOLVIMENTO C
	A linguagem C foi desenvolvida para ser uma linguagem de alto nível, sendo uma linguagem para implementação de sistemas. 
Foi criada com o objetivo de facilitar a criação de programas extensos como menos erros. Suas características principais são:
· Linguagem simplificada;
· Realiza funções matemáticas ou manuseamento de arquivos;
· Múltiplos ficheiros;
· Ponteiros dão maior flexibilidade à linguagem;
· Usa-se valores e não referencias;
· Alto nível de definições de variáveis;
· Segurança de tipo;
· Coletor de lixo;
· Funções alinhadas;
· Estruturas de variáveis;
1.6 PASSO 3
1.6.1 Função Matemática 
Peso = Largura x (Diâmetro Externo/1000) x Peso por metro linear
Algoritmo: atps
Real: P, Dex, L, Pml, Ptf 
Inicio
Escrever (“Qual o peso da bobina? (em kg):“) 
Leia (“P”);
Escrever (“Qual a largura da bobina? (em mm): “);
Escreva (L);
Escrever (“Qual o diametro externo da bobina: “) 
Leia (“Dex”);
Escrever (“Qual o peso por metro linear: “);
Escreva (Pml);
Ptf= peso = larg (Dex/1000) x Pml
Escrever (“O Peso Teórico da bobina filha é = Pt /kg”);
Fim.
1.6.2 Linguagem em C.
int main ( )
{
		float, P, Dex, L, Pml, Ptf;
			printf(“CORTE DE BOBINAS”);
		printf (“\n\n Qual o peso da bobina? (em kilo):“);
scanf (“%f”`, & P);
printf (“\n\nQual a largura da bobina? (em mm)”);
scanf (“%f”, & L);
printf (“\n\nQual o diametro externo da bobina? (em mm)”);
scanf (“%f”, & Dex);
printf (“\n\nQual o peso por metro linear? (em kilo):“);
scanf (“%f”, & Pml);
PTf = P = L*( Dex/1000)*Pml;
printf(“\n\n\n PESO BOBINA FILHA = %5.2f/kg``, P);
system (“pause”);
return 0;
}
1.6.3 Variáveis que armazenaram as informações:
Pseudo Linguagem: Real, Peso, Diametro_Externo, Largura, Peso_por_metro_linear, Peso_total_filha.
Linguagem C: float, P, Dex, L, Pml, Ptf
ETAPA 2
2.1 PASSO 1 E 2 – Desenvolvimento de Algoritmo Utilizando a Linguagem C.
	O objetivo de um programa de computador é executar determinada tarefa, sendo um grupo de comandos logicamente dispostos. O processo de compilação transforma os comandos gravados em um arquivo de linguagem executável por um computador. A compilação faz com que o computador entenda os comandos.
	A única função obrigatória é a main( ). Ela é a primeira função quando a programação é executada. Os parentes ( ) indica que se trata de uma função. Os imbolos “{“ e “}” representam o inicio e o fim de uma função.
2.2 APLICAÇÃO DOS CONCEITOS DE ESTRUTURA DE CONTROLE PARA ANÁLISE DE CONDIÇÕES
	Os algoritmos e programas tem como tarefas fundamentais decidir o que deve ser executado, que permitem determinar qual é a ação a ser tomada.
No decorrer da execução do programa podemos selecionar ações alternativas, alguns comandos representam essas escolhas, como por exemplo:
· Comando if;
· Comando Switch;
· Comando “Se – if”;
· Entre outros.
Os comandos permitem selecionar quais instruções o programa deve ou não executar.
2.3 DESENVOLVIMENTO DE LAÇOS DE REPETIÇÃO
	Para controlar a execução de códigos repetidamente usamos as estruturas de repetição, até que uma condição seja verdadeira. A possibilidade de repetir ações é uma das razões que pelas quais usamos o computador, logo os Laços de Repetição são muito importantes.
	Na linguagem C existem alguns comando de laços: For, Foreach, While e o Do-While.
2.4 DESENVOLVIMENTO EM C
Conforme solicitado no manual da ATPs, utilizando os conceitos de algoritimos desenvolvemos em linguagem C um software qeu seja capas de realizar a conjunção dos paramêtros da Bobina JUMBO.
2.4.a. Criar uma função para receber os pedidos: quantidade em quilos, largura das bobinas e altura das bobinas (unidade de medida milímetros).
main ( )
{
int cont, n;
float larg, qtde, alt;
char resp [1];
for (cont = 1; ; cont ++)
	{
		printf("===== ENTRADA DE PEDIDO =======");
		printf("\n\nDigite o numero do pedido: ");
		scanf("%i", & n);
		printf("Digite a quantidade em Kg: ");
		scanf("%f", & qtde);
		printf("Digite a largura da bobina em mm: ");
		scanf("%f", & larg);
		printf("Digite a altura da bobina em mm: ");
		scanf("%f", & alt);
		printf("\nPedido %i cadastrado com sucesso", n);
		printf("\n\nDeseja continuar? (S/N)");
		scanf("%s", & resp);
		printf("\n\n\n\n");
	}
}
2.4.b. Criar uma função que combine a informação de largura de todos os pedidos informados e resulte em um valor que determine qual o total que será usado da Bobina Jumbo.
# include
main ( )
{ int cont, n;
float larg, total;
for (cont = 1; ; cont ++)
	{
	printf ("Digite o numero do pedido: ");
	scanf ("%i", & n);
	printf ("Digite a largura da bobina em mm: ");
	scanf ("%f", & larg);
	total=larg+cont;
	printf ("\nA largura total da bobina e %i\n\n\n", larg, cont);
	}
}
2.4.c. Fazer um acumulativo para demonstrar o total de volume de produção das bobinas filhas.
# include
main ( )
{ int cont, cod, vol;
char resp [1];
for (cont = 1; ; cont ++)
	{
	printf("===== TOTAL DE PRODUCAO POR PRODUTO =======");	
	printf ("\n\nDigite o codigo do produto: ");
	scanf ("%i", & cod);
	printf ("Digite o volume produzido: ");
	scanf ("%i", & vol);
	printf ("\n\n O produto %i tem %i bobinas produzidas", cod, vol);
	printf ("\n\nDeseja saber o volume de produção de mais algum item? (S/N)");
	scanf ("%s", & resp);
	printf("\n\n\n\n");
	if ( (resp, "N") == 0)
	break;
	}
} 	
2.4.d. Fazer um acumulativo para demonstrar o total de altura na produção das bobinas filhas.
# include
main ( )
{
int cont, cod, alt, vol;
char resp [1];
for (cont = 1; ; cont ++)
	{
	printf("===== ENTRADA DE DADOS =======");
	printf ("\n\nDigite o codigo do produto: ");
	scanf ("%i", & cod);
	printf ("Digite a altura da bobina em mm: ");
	scanf ("%i", & alt);
	printf ("\nO produto %i tem %i de altura total produzidas", cod, vol);
	printf ("Deseja continuar? (S/N)");
	scanf ("%s", & resp);
	printf("\n\n\n\n");
	if (strcmp (resp, "N") == 0)
	break;
	}
}
2.4. e. Fazer um programa para demonstrar o total de refugo através de pedido não provado.
# include 
main ( )
{
int cont, ped, ref;
char resp [1];
for (cont = 1; ; cont ++)
	{
	printf("===== PEDIDO REPROVA =======");
	printf ("\n\nDigite o numero do pedido nao aprovado: ");
	scanf ("%i", & ped);
	printf ("Digite a quantidade de refugo: ");
	scanf ("%i", & ref);
	printf ("\n No pedido %i o total de refugo e de %i bobinas", ped, ref);
	printf ("\n\nDeseja continuar digite S ou N para sair: ");
	scanf ("%s", & resp);
	printf("\n\n\n\n");
	if (strcmp (resp, "N") == 0)
	break;
	}
}
ATPS: Algoritimo e Programação – Bacharelado em Engenharia Elétrica e Engenharia de Automação
e Controle – 2º semestre