SISTEMA DE ESTACIONAMENTO UNIP

Prévia do material em texto

� PAGE \* MERGEFORMAT �1�
UNIP INTERATIVA
Projeto Integrado Multidisciplinar IV
Cursos Superiores de Tecnologia
Sistema de Estacionamento
Polo:
2014
�
UNIP INTERATIVA
Projeto Integrado Multidisciplinar IV
Cursos Superiores de Tecnologia
Sistema de Estacionamento 
						xxxxxxxxxxxxxxxxxxxxxxxxxxx
R.A: xxxxxxxxx
Curso: 
Semestre: 
Polo Brasília
2015
RESUMO
Nesse projeto foi desenvolvido um sistema de estacionamento inteligente a fim de evitar transtornos e frustrações aos clientes do estacionamento na hora de procurar uma vaga para seu veículo. Muitos estacionamentos não tem total controle sobre sua capacidade e perde clientes por falta de controle do fluxo e a organização. O sistema também terá o controle de entrada e saída de caixa, facilitando a contabilidade no final de cada dia e, por conseqüência, no final do mês.
Com esse sistema, o proprietário do estacionamento terá mais controle de seu negócio, e seus clientes se sentirão mais seguros pelo controle de horário e placas dos veículos. Assim como a segurança financeira do estacionamento.
Esse sistema foi criado na linguagem C++. Inicialmente, foi verificado o processo de engenharia, e a aplicação utilizada, o modelo de processo de ciclo de vida e a elaboração do projeto. Realizado a análise dos requisitos, a criação do código fonte, os testes, e a validação do programa, tudo minuciosamente, visando assim o bom funcionamento do programa, e a satisfação do cliente. O sistema foi verificado e totalmente testado para garantir a qualidade do programa. Para garantia de satisfação, a manutenção do software se faz necessária até o final do seu uso.
Palavras Chave: Sistema, Controle de Fluxo, Controle de Caixa, Código Fonte, Linguagem C++, Satisfação do Cliente.
ABSTRACT
This project has developed an intelligent parking system in order to avoid inconvenience and frustration to parking customers on the search for a place for your vehicle. Many parking lots do not have full control over their ability and lose customers because of lack of flow control and the organization. The system will also have the entrance control and cash outflow, facilitating accounting at the end of each day and, consequently, at the end of the month. With this system, the car owner will have more control of your business, and your customers will feel safer by time control and license plates of vehicles. As well as financial security parking. This system was created in C ++. Initially, the engineering process was checked, and the application used, the process model lifecycle and the project design. Conducted the analysis of requirements, the creation of the source code, testing, and program validation, all thoroughly, thus aiming at the smooth operation of the program, and customer satisfaction. The system was verified and fully tested to ensure the quality of the program. To satisfaction guarantee, software maintenance is required until the end of their use.
.
Key words: System, Flow Control, Control Box, Source Code, C ++ Language.
�
SUMÁRIO
01. Introdução.................................................................................................. Pag. 06 
02. Desenvolvimento........................................................................................ Pag. 07 
03.Ciclo de vida do Software........................................................................... Pag. 07 04. Processo de aplicação do Software........................................................... Pag. 08 05. Definição do Sftware.................................................................................. Pag. 09 06. Analise de Requsitos................................................................................. Pag. 09 07. Projeto........................................................................................................ Pag. 10 08. Codificação................................................................................................ Pag. 11 09. Programa Escrito.........................................................................................Pag. 12 10. Testes e implementação............................................................................ Pag. 20 11. Manutenção e Evolução............................................................................ Pag. 21 12. Conclusão................................................................................................. Pag. 22 13. Bibliografia................................................................................................ Pag. 23 
�
 
INTRODUÇÃO 
 	Com o grande crescimento e a quantidade de veículos nas cidades, a procura por vagas em estacionamentos é muito grande. Como hoje em dia o tempo é precioso e, e as pessoas não querem perder tempo procurando vaga para estacionar. Visando solucionar este problema, será criado um sistema que informa o número de vagas disponíveis, interando com o operador informações doa veículos, e ao final o demonstrativo do tempo utilizado e o valor a ser pago. Desse modo quando não houver mais vagas, o próprio sistema informará, evitando assim que algum veículo desperdice tempo em busca de uma Vaga que não existe. Ao final auxilia o operador o controle dos valores obtidos no decorrer do tempo.
DESENVOLVIMENTO
“Quando um software executado é bem-sucedido e atende tato às expectativas como necessidades dos usuários, ele pode operar perfeitamente durante um longo período sendo fácil de modificar e, mais fácil ainda de utilizar, ele é realmente capaz de mudar as coisas para melhor. Porém, quando um software falha quando seus usuários estão insatisfeitos, quando é propenso a erros, quando é difícil modificá-lo e mais difícil ainda utilizá-lo, fatos desagradáveis podem acontecer e, de fato, acontecem. Todos querem construir um software que facilite o trabalho, evitando pontos negativos latentes nas tentativas mal sucedidas. Para ter êxito, é preciso de disciplina no projeto e na construção de software. É Preciso de uma abordagem de engenharia.” (Roger S. Pressman - 2011-prefácio) “Do ponto de vista de um engenheiro de software, é um conjunto de programas, conteúdo (dados) e outros artefatos que são software. Porém, do ponto de vista do usuário, o artefato consiste em informações resultantes que, de alguma forma, tornam a vida dele melhor. ”(Roger S. Pressman, - cap 1) “A elaboração do projeto de software pode-se chamar de Ciclo de Vida do Software” (Shari Pfleeger).
CICLO DE VIDA DO SOFTWARE
Como citado no site ptKioskea.net “o ciclo de vida de um software designa todas as etapas do desenvolvimento do software, da concepção ao seu desaparecimento. ” O ciclo de vida permite detectar os erros o mais rápido possível e assim dominar a qualidade do software, os prazos da sua realização e os custos associados.
Em outras palavras, os modelos de ciclo de vida são o esqueleto, ou as estruturas pré-definidas nas quais se encaixa as fases do processo. De acordo com a NBR ISO/IEC 12207:1998, o ciclo de vida é a “Estrutura contendo processos, atividades e tarefas envolvidas no desenvolvimento, operação e manutenção de um produto de software, abrangendo a vida do sistema, desde a definição de seus requisitos até o término de seu uso”.“Processos de desenvolvimento de software podem ser chamados de Ciclo de Vida do Software. Descreve a 'vida' do programa de software desde a implantação até a implementação, a entrega, a utilização e a manutenção” (Shari Pfleeger). O modelo de ciclo de vida é a primeira escolha a ser feita no processo de software. A partir desta escolha é que se define desde a maneira mais adequada de obter as necessidades do cliente,até quando e como o cliente receberá sua primeira versão operacional do sistema. O que diferencia um processo de software do outro é a ordem em que as fases vão ocorrer, o tempo e a ênfase dados a cada fase, as atividades presentes, e os produtos entregues.
PROCESSOS E APLICAÇÕES DO SOFTWARE
Para criar um software que funcione perfeitamente, agrade o cliente e não estoure o prazo de entrega, é preciso adotar alguns processos e ferramentas de engenharia de software para aplicar os métodos da construção do software. 
“Processos são várias etapas que envolvem atividades, restrições e recursos usados na criação do software” (Shari Pfleeger). Para Paula Filho (2003, p. 4), “um processo de software é um conjunto de passos parcialmente ordenados, constituídos por atividades, métodos, práticas e transformações usados para atingir uma meta”.
Segundo Pressman, Paula Filho e Sommerville, será necessário quatro atividades fundamentais no processo de software: Especificação de Software, Desenvolvimento do Software, Validação do Software e Evolução do Software. Especificação de Software (Especificação de Requisitos): Descrição do software, levantamento dos dados.
 Desenvolvimento do Software: Escolha da linguagem de programação (para criação do código fonte), modelo do software, montagem da arquitetura.
Validação do Software: Verificação do software para garantir que não contém erros, e que o cliente está satisfeito com o produto final. 
É feito na entrega do produto ao cliente a Evolução do Software: Manutenção e atualização do conforme exigência do cliente, até que não o utilize mais. O método utilizado é a Análise de Projeto Estruturado, com técnicas de algoritmos onde algumas de suas partes são abstraídas em uma função. Cada software é diferente. Para aumentar sua qualidade, deve-se usar as aplicações de software. Para esse software em questão, será usado o Sistema de Processamento de Transações (STP), que cada desenvolvedor se empenhe ao máximo e com o melhor preparo. O STP possui funções de monitoramento de transações que incluem detecção e resolução de impasses (deadlock) e podem ser inevitáveis em casos de cruzamento de dados. Além de possuir inflexibilidade, resposta rápida, confiabilidade, processamento controlado, armazenamento e recuperação de dados. Neste software usará sua característica de manipulação dos dados: cálculos, classificação, disposição, produção de documentos que podem ser impressos ou exibidos na tela do computador. 
De acordo com Humphrey, autor do PSP, à medida que os profissionais de desenvolvimento de software aprendem a avaliar seus trabalhos, a analisar essas medidas e a definir e atingir metas de melhoria, passam a enxergar os benefícios de usar o processo definido e são motivados constantemente a isso. Falconi (1992) afirma que produto ou serviço de qualidade é aquele que atende perfeitamente, de forma confiável, acessível, segura e no tempo certo, às necessidades dos clientes.
DEFINIÇÃO DO SOFWARE
Nessa fase, é preciso ouvir e entender o que o cliente está pedindo, a forma de fazer, os custos, e as horas que serão utilizadas na elaboração do software. 
A escolha certa do modelo do processo a ser utilizado, vai definir a qualidade do produto final.  O Modelo Cascata é o modelo mais clássico e um dos mais utilizados por desenvolvedores de software, e é a base para muitos outros modelos. Nele, incorpora a abordagem de processos, métodos e ferramentas para a criação do software. É o modelo mais rígido e menos administrativo. Como terá uma proposta de software pequeno, bem definido, com pouco prazo e que, muito provavelmente não precisará de alterações, pois o cliente sabe exatamente o que quer para seu sistema, será utilizado Modelo Incremental (desenvolvimento em fases). De acordo com Pressman (2006), Sommerville (2007), Paula Filho (2003) e outros autores, o modelo incremental seria a aplicação do modelo cascata por diversas vezes em um mesmo projeto. “O sistema é dividido em subsistemas por funcionalidades, geralmente há dois sistemas funcionando em paralelo: o sistema em desenvolvimento e o sistema em produção. O sistema em produção é o que está sendo utilizado pelo cliente e pelo usuário; o sistema em desenvolvimento é a versão seguinte, que irá substituir o sistema atualmente em execução”. (Shari Pfgleer) O Modelo Incremental aplica um sistema linear (como no modelo cascata) combinado com iterações. Esse modelo é um modelo evolutivo do modelo cascata. O ciclo de desenvolvimento do programa também é o mesmo do modelo cascata:
Análise de Requisitos (Comunicação, iteratividade); Projeto (Planejamento Modelagem); Codificação (Construção); Testes e Depuração; Implantação;
Manutenção e Evolução do Sistema. Nesse modelo, em todas as fases do desenvolvimento terá a iteratividade com o cliente.
ANÁLISE DE REQUISITOS (COMUNICAÇÃO)
A Análise de Requisitos é um aspecto importante no Gerenciamento de Projetos, é a responsável por coletar dados indispensáveis, necessários, exigências de que o usuário necessite para solucionar um problema e alcançar seus objetivos. Assim como determinar as suas expectativas de um usuário para determinado produto.
Segundo a IEEE (1990) a análise de requisitos é um processo que envolve o estudo das necessidades do usuário para se encontrar uma definição correta ou completa do sistema ou requisito de software. Essa análise de requisitos é vital para o desenvolvimento do sistema, ela vai determinar o sucesso ou o fracasso do projeto. Os requisitos colhidos devem ser quantitativos, detalhados e relevantes para o projeto. Pois eles fornecerão a referência para validar o produto final, estabelecerão o acordo entre cliente e fornecedor sobre o que e o software fará e consequentemente reduzirão os custos de desenvolvimento, pois requisitos mal definidos implicam num retrabalho. Assim, é muito importante a comunicação e o envolvimento constante com os usuários do software, pois eles influenciarão no resultado final do produto. Inicialmente, será analisado a proposta do cliente para organizar e distribuir as tarefas, contabilizar o custo e as horas do produto, dialogar com o cliente para entender perfeitamente como ele deseja o software.
O modelo vai apresentar ferramentas que facilitarão o entendimento do sistema, como as funcionalidades, informações e comportamento do sistema. Foi utilizado o modelo de Casos de Uso, para definir os conceitos do sistema. É o modelo mais importante para dialogar com o cliente e validar os requisitos do sistema, escolher e consolidar funções, interfaces, desempenho, o contexto e as restrições do sistema.
Revisar juntos, cliente e analistas. Avaliar o objetivo do projeto com o intuito de eliminar possíveis redundâncias, inconsistências e omissões do sistema, obtendo uma mesma visão. A análise de requisitos vai ser o processo a determinar as necessidades e interesses dos desenvolvedores para atingir seus objetivos.
No final da etapa de análise já é possível ter uma estimativa mais precisa de investimento e tempo para a produção do sistema desejado.
PROJETO (PLANEJAMENTO)
O projeto basicamente enfatiza a proposta de solução do problema que atenda os requisitos levantados na análise. Em outras palavras, a análise é a investigação para tentar descobrir o que o cliente quer e o projeto consiste em propor a solução com base no estudo levantado na análise. Alguns aspectos devem ser considerados nessa fase de projeto do sistema, como: arquitetura do sistema, linguagem de programação utilizada, Sistema Gerenciador de Banco de Dados (SGBD) utilizado, padrão de interface gráfica, entre outros. No projeto é gerada uma descrição computacional, mencionando o que o software deve fazer, e deve ser coerente com a descrição realizada na fase de análise de requisitos (Hudson L. Pinto – Artigo Revista DevMedia) Na concepção geral, foi definido e elaborado as especificações da arquitetura geral do software. Essas especificações incluem o projeto das interfaces, banco de dados, características físicas dosistema, tais como número, tipos e localizações das estações de trabalho, hardware de processamento, cabeamento e os dispositivos de rede; deve especificar os procedimentos para testar o sistema completo antes da instalação. Na concepção detalhada, foi definido precisamente cada subconjunto do software, design da interface, e os riscos. Definir com o cliente qual o cronograma do projeto, qual incremento vai ser desenvolvido e entregue primeiro. Inicializará pelo incremento das placas, modelo e cor dos veículos, no próximo incremento, foi desenvolvido a tarifação, com preço na primeira hora e, outro valor nas demais horas. A seguir, o incremento para emissão de recibo e a gestão de caixa.
CODIFICAÇÃO (CONSTRUÇÃO) 
A codificação é o desenvolvimento propriamente dito. Aqui são escritas milhares de linhas de códigos que interligação o sistema com bancos de dados e outros dispositivos a fim de produzir o resultado que foi especificado no projeto.
Para gerar o código do software, foi colocado em linguagem computacional todos os requisitos levantados e analisados até agora. O sistema é codificado a partir da descrição computacional da fase de projeto em uma outra linguagem, onde se torna possível a compilação e geração do código-executável para o software [...]utilizar na implementação ferramentas de software e bibliotecas de classes preexistentes para agilizar a atividade, como também o uso de ferramentas CASE, que dinamizam o processo de desenvolvimento, nas várias atividades, onde inclui-se geração de código-fonte,documentação,etc. (Hudson L. Pinto – Artigo Revista DevMedia) Foi desenvolvido o sistema de estacionamento em ambiente Windows, com algoritmos em português estruturado, o portugol (pseudocódigo), porém traduzida em linguagem C. Utilizando o programa DEV C++, em linguagem C++, a metodologia utilizada é a Programação Seqüencial, em que as instruções são executadas umas após as outras, na ordem em que foram discutidas e escritas, em conjunto de comandos que serão executados numa seqüência linear, de cima para baixo, linha a linha. Pode aparecer em qualquer estrutura de controle, agrupada ou não por blocos. O modelo de sequência facilita o entendimento, facilitam a comunicação da equipe, diminuem a ambigüidade e permitem a rastreabilidade dos códigos construídos. Inserida a biblioteca < STDIO.H> e a função “main” (que é a principal função que o programa executa). A qualidade na fase de construção envolve definir medidas e critérios para determinar se o sistema está em um nível satisfatório de aceitação. O desenvolvimento iterativo permite a realização de testes contínuos, tanto nesse processo tradicional, quanto nos métodos ágeis.
O PROGRAMA ESCRITO
Verifica-se a disponibilidade de vagas, cadastro dos veículos contemplando placa, modelo e marca, tempo e valor do uso do estacionamento.
Código: */
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
void INICIALIZA();
void INSERIR(int I);
void CADASTRAR_VEICULO();
void CADASTRAR_VAGA();
void CONTROLAR_ESTACIONAMENTO();
void CONSULTAR_VAGAS();
void LISTAR_OCUPADAS();
void LISTAR_VEICULOS();
struct
{
char PLACA[8], MODELO[20], MARCA[20], COR[10];
int STATUS;
}CARRO[10];
int NVEI=0; //contador de veículos cadastrados
//int NVAG=0; //contador de vagas cadastradas
//-----------------------------------------------------------------------------
main()
{
int OP;
FILE* P;
INICIALIZA();
//abre o arquivo pro fopen "w" não substituir o que já existe
P=fopen("CARRO.txt", "r");
fread(&CARRO, sizeof(CARRO), 1, P);
fclose(P);
do{
printf("CONTROLE DE ESTACIONAMENTO\n\n");
printf("1. Cadastrar veiculo\n2. Cadastrar vaga\n3. Controle do estacionamento\n");
printf("4. Consultar vagas\n5. Listar vagas ocupadas\n6. Listar veiculos\n7. Sair\n\nOpcao: ");
scanf("%d", &OP);
switch(OP)
{
case 1:
{
system("cls");
CADASTRAR_VEICULO();
break;
}
case 2:
{
system("cls");
CADASTRAR_VAGA();
break;
}
case 3:
{
system("cls");
CONTROLAR_ESTACIONAMENTO();
break;
}
case 4:
{
system("cls");
CONSULTAR_VAGAS();
break;
}
case 5:
{
system("cls");
LISTAR_OCUPADAS();
break;
}
case 6:
{
system("cls");
LISTAR_VEICULOS();
break;
}
case 7: break;
default:
{
system("cls");
printf("Opcao invalida!\nEnter para voltar ao menu");
getch();
system("cls");
}
}
}while(OP!=7);
getchar();
}
//-----------------------------------------------------------------------------
void INICIALIZA()
{
int I;
for(I=0; I<10; I++)
CARRO[I].STATUS=0; 
}
//-----------------------------------------------------------------------------
void INSERIR(int I)
{
char PL[8];
int I2, TESTE, TAM_PLACA;
FILE *P;
puts("Digite a placa: ");
fflush(stdin);
gets(PL);
strupr(PL);//deixa caracteres da placa em maiúsculo
for(I2=0; I2<10; I2++)
{ 
if(strcmp(PL, CARRO[I2].PLACA)==0)
{
printf("\nVeiculo já cadastrado, informe outra placa\n\n");
INSERIR(I);
}
}
strcpy(CARRO[I].PLACA, PL);
TAM_PLACA=strlen(CARRO[I].PLACA);
if(TAM_PLACA!=7)
{
if(TAM_PLACA<7)
{
printf("\nPlaca invalida\nDigitos insuficientes\n\n");
INSERIR(I);
}
else//(TAM_PLACA>7)
{
printf("\nPlaca invalida\nMuitos digitos\n\n");
INSERIR(I);
}
}
//testa se 3 primeiros digitos são letras
for(I2=0; I2<3; I2++)
{
TESTE=isalpha(CARRO[I].PLACA[I2]);//retorna 1 se for letra
if(TESTE==0)
{
printf("\nPlaca invalida\nTres primeiros digitos devem ser letras!\n\n");
INSERIR(I);
}
}
//testa se 4 últimos digitos não são letras
for(I2=3; I2<7; I2++)
{
TESTE=isalpha(CARRO[I].PLACA[I2]);//retorna 1 se for letra
if(TESTE==1)
{
printf("\nPlaca invalida\nQuatro ultimos digitos devem ser numeros!\n\n");
INSERIR(I);
}
}
puts("\nDigite o modelo: ");
fflush(stdin);
gets(CARRO[I].MODELO);
//deixa string em minúsculo
strlwr(CARRO[I].MODELO);
//deixa primeiro caractere maiúsculo
CARRO[I].MODELO[0]=toupper(CARRO[I].MODELO[0]);
puts("\nDigite a marca: ");
fflush(stdin);
gets(CARRO[I].MARCA);
strlwr(CARRO[I].MARCA);
CARRO[I].MARCA[0]=toupper(CARRO[I].MARCA[0]);
puts("\nDigite a cor: ");
fflush(stdin);
gets(CARRO[I].COR);
strlwr(CARRO[I].COR);
CARRO[I].COR[0]=toupper(CARRO[I].COR[0]);
CARRO[I].STATUS=1;
P=fopen("CARRO.txt", "w");
fwrite(&CARRO, sizeof(CARRO), 1, P);
fclose(P);
}
//-----------------------------------------------------------------------------
void CADASTRAR_VEICULO()
{
int I, FLAG=1;
for(I=0; I<10; I++)
{
if(CARRO[I].STATUS==0)
{
INSERIR(I);
FLAG=0;
system("cls");
break;
}
}
if(FLAG==1)
{
printf("Sem espaco para cadastrar\nEnter voltar ao menu...");
getch();
system("cls");
}
}
//-----------------------------------------------------------------------------
void CADASTRAR_VAGA()
{}
//-----------------------------------------------------------------------------
void CONTROLAR_ESTACIONAMENTO()
{}
//-----------------------------------------------------------------------------
void CONSULTAR_VAGAS()
{}
//-----------------------------------------------------------------------------
void LISTAR_OCUPADAS()
{}
void LISTAR_VEICULOS()
{
int I, X=1;
FILE *P;
P=fopen("CARRO.txt", "r");
fread(&CARRO, sizeof(CARRO), 1, P);
for(I=0; I<10; I++)
{
if(CARRO[I].STATUS==1)
{
printf("Veiculo %d\nPlaca: %s\t Modelo: %s\t Marca: %s\t Cor: %s\n\n", I+1, CARRO[I].PLACA, CARRO[I].MODELO, CARRO[I].MARCA, CARRO[I].COR);
X=0;
}
}
if(X==0)
{
printf("\nEnter voltar ao menu...");
getch();
system("cls");
}
else
{
puts("Nenhum veiculo cadastrado\nEnter voltar ao menu...");
getch();
system("cls");
}
}
OUTRA PARTE DO PROGRAMA:
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <time.h>
float precoinicial = 5.00, precoporhoramais = 2.00, precofinal, precohora;
int opc, horaentrada, horasaida, somahora, minutoentrada, minutosaida;
char placaentrada[7], placasaida[7], placa[7];
int main(){
 while (opc != 3)
 {
 printf("valor da primeira 1hora R$%.2f\napos 1hora sera cobrado mais R$%.2f por hora\n", precoinicial, precoporhoramais);
 printf("menu\nEntrada=1\nSaida=2\nFinalizar=3\n");
 scanf("%d", &opc);
 
 switch (opc) {
 case 1:
 printf("Placa\n Hora de entrada\nData");
 fgets(placaentrada, sizeof(placaentrada), stdin);
 printf("Digite a Hora");
 scanf("%d", & horaentrada);
 printf("Digite a Minuto");
 scanf("%d", & minutoentrada);
 break;
 case 2:
 printf("digite a placa do carro");
 fgets(placasaida, sizeof(placasaida), stdin);
 printf("digite a Hora");
 scanf("%d", horasaida);
 printf("digite o Minuto");
 scanf("%d", minutosaida);
 somahora = horaentrada + horasaida;
 if (horaentrada < horasaida) {
 precofinal = precohora + (somahora * 2);
 printf("Hora de Entrada: %d:%d \nHora de Saida: %d:%d\nPlaca do carro:%s", horaentrada, horasaida, placa);
 printf("valor a pagar: R$%.2f", precofinal);
 }
 printf("Hora de Entrada: %d:%d \nHora de Saida: %d:%d\nPlaca do carro:%s", horaentrada, horasaida, placa);
 printf("Valor a Pagar: R$%.2f", precoinicial);
 break;
 case 3:
 printf("finalizado");
 break;
 }
 }
 system("PAUSE");
 return (0);
}
 TESTES E DEPURAÇÃO
“O objetivo dos testes é revelar falhas no produto. Por isso, a natureza dos teste destrutiva e não construtiva, pois visaa exposição de problemas em sua estrutura e em conseqüência, a solução do problema antes de ser entregue ao cliente.” (Arildo Cláudio Dias Neto – Artigo Revista DevMedia). Para testar o sistema, tem o teste funcional, onde a questão é se o sistema integrado realiza as funções especificadas nos requisitos. Tem o teste de desempenho para ver se os requisitos não-funcionais foram comparados. O teste de aceitação, para avaliar se o sistema satisfaz o cliente. E o teste de instalação, onde os usuários executam as funções do sistema e documentam problemas do verdadeiro local de operação. A realização de testes não deve ser feita de qualquer maneira ou por qualquer pessoa. Para obter um bom resultado, o ideal é estabelecer procedimentos para testes, que deverá incluir: o que deve ser testado, qual dado deverá ser inserido, e se qual o perfil da pessoa que irá testar: amador, experiente, usuário, etc... Os testes se desenvolvem ao longo dos componentes que vão sendo liberados; são os de unidade e os de integração. A homologação se dá com o sistema completo ou por módulos, Conforme o cliente vai recebendo.
IMPLANTAÇÃO E VALIDAÇÃO DO SOFTWARE
A implantação ocorre após o sistema ter passado satisfatoriamente por testes de aceitação. O sistema é transferido do ambiente de desenvolvimento para o ambiente de produção. Em muitos casos a implantação é a etapa mais dolorosa do processo de desenvolvimento de sistemas, já que implicam movimentar pessoas, hardwares, softwares e muitas vezes com a empresa em pleno funcionamento.
Um plano de implantação foi desenvolvido e validado junto ao patrocinador do projeto. Um repositório é disponibilizado, e todos os documentos gerados durante o projeto são guardados digitalmente nesse repositório. Um contrato que expresse claramente as expectativas, as responsabilidades e as obrigações de ambos (grupo de implantação e organização a ser capacitada) elaborados. A utilização do software em produção em um departamento, como plano-piloto, é realizada e certificada (homologação). Uma certificação de uso do sistema em ambiente de produção é emitida pelo implantador e homologada pelo usuário. Dependendo do tipo e tamanho do sistema é necessário determinar momentos estratégicos para a implantação a fim de provocar menos impacto nos procedimentos da empresa. Paralelamente, tem também a etapa de treinamento que consiste em apresentar aos usuários o novo sistema e auxiliá-los nos procedimentos que cada um deverá realizar. Nessa fase se faz nescessário ficar muito atento quanto aos riscos que podem vir a ocorrer durante a implantação do programa.
MANUTENÇÃO E EVOLUÇÃO DO SOFTWARE
A última etapa do processo de desenvolvimento de sistemas é a manutenção. Ela inicia logo após a implantação e não terá fim, ou seja, existirá enquanto o sistema existir. A manutenção é uma etapa de muitas controvérsias, por isto é importante existir um documento que regulamente o que é manutenção, quais as responsabilidades de clientes, usuários e desenvolvedores, bem como os custos envolvidos nessas atividades. Segundo Sommerville, existem três diferentes tipos de manutenção de software: 
1. Correção de Defeitos – Erros decodificação podem ser baratos para serem corrigidos; Erros de projetos são um pouco mais caro, pois podem precisar reescrever componentes no programa; Erros de requisitos são os mais caros devido ao extenso reprojeto que poderá ser necessário. 
 2. Adaptação Ambiental – É necessário quando algum aspecto muda, como hardware, plataforma do sistema operacional, ou outro software de apoio sofrem mudanças.
3. Adição de Funcionalidade – É necessário quando os requisitos mudam em resposta às mudanças organizacionais ou de negócios. Essa fase, é muito maior do que os outros tipos de manutenção. 
CONCLUSÃO
Diante do enorme avanço da tecnologia e sua acessibilidade, pequena e medias empresas vem buscando melhorar os serviços prestados a seus clientes e sua expansão para outros setores ou até mesmo cidades, em decorrência disto o parque tecnológico destas empresas vem sendo modernizados visando agregar valor a seu negócio.
Vimos aqui um exemplo que pode ser facilmente implantado em uma empresa de pequeno porte, porem com alguns investimentos e ajustes podemos implantar em uma empresa de médio e grande porte mantendo uma boa qualidade. 
BIBLIOGRAFIA
 
 http://www.luis.blog.br/etapas-processo-desenvolvimento-sistemas.aspx, Educação, Internet e cidadania 
http://www.infoescola.com/engenharia-de-software/analise-de-requisitos, infoescolaa, Ana Paula Quiterio 
 
http://www.visaoi.com.br/visaoi/home/pagina/id/12/Projeto-para-Sistemas, visaoi 
 
http://www.devmedia.com.br/artigo-engenharia-de-software-introducao-a-teste-de-software/8035 - (em 12/11/2014)
PFLEEGER, SHARI L. - Engenharia de Software Teoria e Prática – 2ª edição
http://www.devmedia.com.br/ciclos-de-vida-do-software-artigo-revista-engenharia-de-software-magazine-36/21099, devmedia, Ana Bárbara Lins de Macêdo e Rodrigo Spinola. 
SOMMERVILLE, IAN – Engenharia de Software – 6ª , 7ª e 9ª edição
PRESSMAN, ROGER – Engenharia de Software – Uma abordagem Profissional - 7ª edição
http://pt.kioskea.net/contents/225-ciclo-de-vida-de-um-software (em 10/11/2014)
Livro Texto –Professor Ivanir Costa - Engenharia de Software – Universidade Paulista – 2014.
�