PIM IV - DESENVOLVIMENTO DE SISTEMA EM LINGUAGEM C - CADASTRO E RELATÓRIOS DE UMA STARTUP DE SOLUÇÕES AMBIENT

Prévia do material em texto

UNIVERSIDADE PAULISTA – UNIP - EAD
PROJETO INTEGRADOR MULTIDSCIPLINAR CURSO
SUPERIOR DE TECNOLOGIA EM ANÁLISE E
DESENVOLVIMENTO DE SISTEMAS
DESENVOLVIMENTO DE SISTEMA EM LINGUAGEM C -
CADASTRO E RELATÓRIOS DE UMA STARTUP DE
SOLUÇÕES AMBIENTAIS
ALUNO(A): FABIANA MARQUES COSTA R.A.: 1620190
RIO CLARO/SP
2024
FABIANA MARQUES COSTA – 1620190
DESENVOLVIMENTO DE SISTEMA EM LINGUAGEM C
CADASTRO E RELATÓRIOS DE UMA STARTUP DE SOLUÇÕES AMBIENTAIS
PROJETO INTEGRADOR MULTIDSCIPLINAR
CURSO SUPERIOR DE TECNOLOGIA EM ANÁLISE E
DESENVOLVIMENTO DE SISTEMAS
ALUNO(A): FABIANA MARQUES COSTA R.A.: 1620190
Projeto Integrado Multidisciplinar – PIM IV, apresentado como
um dos pré-requisitos para aprovação no bimestre vigente, no
Curso Superior de Tecnologia em Análise e Desenvolvimento de Sistemas.
Orientador (a): Profa. Me. Karhyne Assis
RIO CLARO/SP
2024
Resumo
Este trabalho tem como objetivo apresentar a proposta de um sistema computacional
desenvolvido em linguagem C para atender às demandas operacionais de uma startup
especializada em soluções ambientais. A startup atua no cadastro, mapeamento e
gerenciamento de indústrias que necessitam tratar materiais particulados e gases
emitidos durante seus processos produtivos. O sistema foi projetado para gerenciar
dados de clientes e gerar relatórios detalhados, tanto individuais quanto globais, sobre
as atividades relacionadas ao tratamento de resíduos ambientais.
O desenvolvimento do sistema atende às demandas operacionais crescentes da
startup, resultantes do aumento significativo de contratos, além de estar em
conformidade com os requisitos da Lei Geral de Proteção de Dados (LGPD). Para isso,
foram implementados mecanismos de criptografia que garantem a segurança das
informações sensíveis dos usuários.
O sistema proposto não apenas facilita o gerenciamento interno das operações da
startup, mas também fornece informações estratégicas para os clientes e órgãos
governamentais. Dessa forma, busca-se otimizar a gestão ambiental de indústrias de
médio e grande porte, promovendo uma solução eficiente e segura para o mercado
ambiental.
Palavras-chave: Startup, Soluções ambientais, Software.
Abstract
This work aims to present the proposal of a computational system developed in C language to
meet the operational demands of a startup specialized in environmental solutions. The startup
operates in the registration, mapping, and management of industries that need to treat
particulate materials and gases emitted during their production processes. The system was
designed to manage client data and generate detailed reports, both individual and global, on
activities related to environmental waste treatment.
The system's development addresses the growing operational demands of the startup, resulting
from a significant increase in contracts, while also complying with the requirements of the
General Data Protection Law (LGPD). To achieve this, encryption mechanisms were
implemented to ensure the security of users' sensitive information.
The proposed system not only facilitates the internal management of the startup's operations
but also provides strategic information for clients and government agencies. In this way, it seeks
to optimize the environmental management of medium and large-scale industries, promoting an
efficient and secure solution for the environmental market.
Keywords: Startup, Environmental solutions, Software.
SUMÁRIO
1. INTRODUÇÃO.......................................................................................................................... 6
2. METODOLOGIA........................................................................................................................7
Fases do Modelo Cascata................................................................................................. 7
Documentação e Registro................................................................................................. 9
Justificativa da Escolha......................................................................................................9
2.1 Apresentação da Linguagem C....................................................................................... 10
2.2 Requisitos do Sistema Computacional............................................................................ 11
Requisitos Funcionais (RF):.............................................................................................11
Requisitos Não Funcionais (RNF):...................................................................................11
2.3 Arquitetura e Funcionalidades do Sistema...................................................................... 12
2.4 Tela de Login................................................................................................................... 12
2.5 Tela de Menu................................................................................................................... 14
Opções do Menu..............................................................................................................14
Organização e Usabilidade..............................................................................................15
2.6 Tela de Cadastro..............................................................................................................16
Validação dos Dados....................................................................................................... 17
Importância da Funcionalidade........................................................................................17
2.7 Tela Listar Cliente............................................................................................................ 18
Funcionalidades Disponíveis........................................................................................... 18
2.8 Relatório Individual / Global.............................................................................................20
2.9. Programa em Linguagem em C......................................................................................23
2.10. Compilação do Programa............................................................................................. 36
Documentação do Sistema..............................................................................................37
Arquivos Incluídos:...........................................................................................................38
3. CONCLUSÃO.................................................................................................................... 39
REFERÊNCIAS..................................................................................................................... 41
1. INTRODUÇÃO
O desenvolvimento de sistemas computacionais tornou-se indispensável para
organizações que enfrentam demandas operacionais crescentes, especialmente em
setores que lidam com questões ambientais e regulatórias. Este trabalho tem como
objetivo criar um sistema computacional para uma startup de soluções ambientais,
abordando seus requisitos, arquitetura e funcionalidades. A proposta visa atender às
necessidades decorrentes do crescimento exponencial no número de contratos da
startup, o que aumentou significativamente a complexidade de suas operações.
A startup em questão dedica-se ao cadastramento, mapeamento e gerenciamento de
indústrias que necessitam reduzir a emissão de material particulado e gases
provenientes de processos produtivos. Através de um sistema computacional eficiente,
a empresa busca oferecer informações estratégicas que auxiliem seus clientes na
obtenção de benefícios fiscais e permitam ao governo monitorar os índices de poluição
industrial em diferentes regiões. Conforme destacado por Pressman (2016), o uso de
sistemas bem projetados possibilita a integração entre operações organizacionais e
requisitos externos, promovendo maior eficiência e confiabilidade.
Inicialmente voltada para o mercado regional, a startup enfrentou desafios devido ao
aumentosubstancial no volume de contratos, o que evidenciou a necessidade de um
sistema computacional robusto. Este sistema deverá gerenciar tarefas como cadastro
de clientes, atualização de dados e geração de relatórios personalizados, otimizando
os processos internos e reduzindo possíveis inconsistências manuais. Além disso, o
sistema proposto adere aos requisitos da Lei Geral de Proteção de Dados (LGPD),
utilizando criptografia para proteger informações sensíveis de clientes e usuários, em
conformidade com as diretrizes descritas por Brasil (2018).
A pesquisa e o desenvolvimento do sistema foram fundamentados nos conhecimentos
adquiridos nas disciplinas de Linguagem e Técnicas de Programação e Engenharia de
Software I. Esses conteúdos teóricos e práticos foram aplicados no desenvolvimento de
um sistema desktop, implementado em linguagem C. De acordo com Manzano (2013),
a linguagem C se destaca por sua capacidade de manipulação direta de hardware e
por oferecer ferramentas eficientes para a construção de soluções de alto
desempenho. Essas características são cruciais para atender às necessidades da
startup, oferecendo um sistema seguro e confiável.
Dessa forma, o presente trabalho busca não apenas resolver os desafios operacionais
da startup, mas também propor uma solução tecnológica robusta, segura e alinhada às
demandas contemporâneas do mercado ambiental. A importância do sistema se
destaca ao oferecer suporte para uma melhor gestão ambiental e ao reforçar a posição
estratégica da startup no setor.
2. METODOLOGIA
Neste trabalho, adotou-se o Modelo Cascata como metodologia para o
desenvolvimento do sistema computacional voltado à startup de soluções ambientais.
Esse modelo, descrito inicialmente por Royce (1970), é caracterizado por uma
abordagem linear e sequencial, sendo especialmente apropriado em contextos onde os
requisitos do projeto estão bem definidos e documentados. A principal vantagem do
Modelo Cascata reside em sua estruturação em fases bem delineadas, permitindo que
cada etapa seja concluída antes do início da próxima, o que garante maior controle e
qualidade no processo de desenvolvimento (PRESSMAN, 2016).
A escolha do Modelo Cascata também se justifica pela necessidade de criar uma
solução robusta e segura, onde cada funcionalidade é detalhadamente projetada e
implementada com base em requisitos claros. De acordo com Manzano (2013), a
clareza e a organização nas etapas de desenvolvimento são essenciais para sistemas
computacionais que utilizam a linguagem C, especialmente em projetos que
demandam alto desempenho e confiabilidade.
Fases do Modelo Cascata
1. Especificação de Requisitos:
Esta etapa inicial consistiu no levantamento e análise detalhada das
necessidades da startup. A equipe identificou funcionalidades essenciais,
requisitos legais, como a conformidade com a Lei Geral de Proteção de Dados
(LGPD), e expectativas dos usuários. Essa análise foi fundamental para alinhar
as necessidades operacionais da startup com as diretrizes legais e garantir que
o sistema fosse eficiente e seguro. Conforme Pressman (2016), essa fase é
crucial para estabelecer uma base sólida no desenvolvimento de sistemas,
reduzindo riscos e prevenindo retrabalho.
2. Projeto do Software:
Com os requisitos definidos, a modelagem do sistema foi realizada, incluindo a
definição da arquitetura e a elaboração de diagramas, como casos de uso e
diagramas de atividades. Esses diagramas permitiram uma visualização clara
das interações entre os usuários e o sistema, facilitando a transição para a etapa
de codificação (SOMMERVILLE, 2011). Segundo Manzano (2013), na linguagem
C, o planejamento adequado da estrutura do programa é essencial para garantir
um código eficiente e legível, especialmente em projetos de grande porte.
3. Implementação:
Nesta fase, o código foi desenvolvido utilizando a linguagem C, contemplando as
funcionalidades planejadas, como login, cadastro de clientes, atualização de
dados e geração de relatórios. A linguagem C foi escolhida por sua eficiência e
flexibilidade, alinhadas à necessidade de um sistema de alto desempenho. De
acordo com Manzano (2013), C é uma linguagem amplamente utilizada no
desenvolvimento de sistemas que exigem manipulação direta de recursos de
hardware, tornando-a uma escolha ideal para este projeto.
4. Teste Unitário (Validação):
Após a implementação de cada módulo, foram realizados testes unitários para
verificar o funcionamento individual das funcionalidades. Esses testes
garantiram a identificação e correção de erros em nível modular, antes da
integração dos componentes. Testes bem estruturados são recomendados por
Pressman (2016) como uma prática essencial para assegurar a confiabilidade do
sistema em desenvolvimento.
5. Integração:
Na fase de integração, os diferentes módulos do sistema foram combinados,
garantindo que funcionassem de forma coesa. Essa etapa é crucial para validar
a comunicação entre os componentes e assegurar que o sistema atenda aos
requisitos funcionais. Manzano (2013) reforça a importância de uma integração
cuidadosa em projetos implementados em linguagem C, devido à necessidade
de compatibilizar estruturas de dados e funções de diferentes módulos.
6. Teste de Sistema (Validação):
Após a integração, testes de validação foram realizados para confirmar que
todos os requisitos especificados foram atendidos. Esses testes também
avaliaram o desempenho do sistema sob diferentes condições de uso. Conforme
Sommerville (2011), essa etapa é indispensável para garantir que o produto final
esteja alinhado às expectativas dos usuários e às exigências operacionais.
7. Operação e Manutenção:
Com a entrega do sistema à startup, foi oferecido suporte técnico inicial, além de
coleta de feedbacks dos usuários. Essas informações possibilitaram ajustes e
melhorias no sistema, garantindo que ele continuasse alinhado às demandas
operacionais e legais da empresa.
FIGURA 1 - Modelo Cascata
Fonte: Agenor Technology
Documentação e Registro
Uma das características mais relevantes do Modelo Cascata é a ênfase na
documentação em todas as fases do desenvolvimento. No presente trabalho, cada
etapa foi devidamente documentada, desde a especificação inicial dos requisitos até os
testes finais. Esse registro detalhado proporcionou transparência e suporte para
consultas futuras, além de servir como base para eventuais expansões do sistema
(PRESSMAN, 2016).
Justificativa da Escolha
A escolha do Modelo Cascata foi fundamentada na natureza do projeto, onde os
requisitos estavam claramente definidos desde o início. Essa metodologia permitiu que
as etapas fossem executadas de forma linear, minimizando riscos e garantindo a
organização do processo de desenvolvimento. Além disso, a estrutura sequencial do
modelo contribuiu para a eficiência na comunicação entre os membros da equipe e no
atendimento às demandas específicas da startup de soluções ambientais. De acordo
com Manzano (2013), em sistemas desenvolvidos na linguagem C, a adoção de uma
metodologia bem definida, como o Modelo Cascata, auxilia na estruturação lógica do
código, evitando inconsistências e facilitando a manutenção.
A adoção do Modelo Cascata resultou em um fluxo de desenvolvimento claro e
organizado, permitindo a entrega de um sistema robusto, seguro e eficiente. A
metodologia demonstrou-se adequada para atender às necessidades do projeto,
maximizando a eficiência no atendimento às demandas da startup.
2.1 Apresentação da Linguagem C
A linguagem C foi criada em 1972 por Dennis Ritchie, nos laboratórios Bell, com o
objetivo de ser utilizada no desenvolvimento do sistema operacional Unix, no
computador PDP-11, sob a liderança de Ken Thompson. A proposta de Ritchie era criar
uma linguagem eficiente e flexível, capaz de substituir o Assembly em diversas tarefas,
mantendo a possibilidade de manipulação direta do hardware (RITCHIE, 1988). Desde
então, a linguagem C tornou-se uma das mais influentes no mundo da programação,
sendo amplamente utilizada para o desenvolvimento de sistemas operacionais,softwares de alto desempenho e linguagens modernas.
Do ponto de vista técnico, a linguagem C descende da ALGOL 60, desenvolvida em
1960, que introduziu conceitos fundamentais para linguagens modernas, como o uso
de estruturas de controle e sintaxe estruturada (WIRTH, 1976). A ALGOL permitia aos
programadores abstrair os detalhes do hardware, focando na lógica do programa.
Apesar de sua inovação, a ALGOL enfrentou resistência na adoção, devido à
necessidade de alto conhecimento técnico dos programadores e limitações de
compatibilidade com os sistemas da época (SEBESTA, 2012).
A padronização oficial da linguagem C ocorreu em 1985, quando o American National
Standards Institute (ANSI) definiu o padrão "C ANSI". Essa padronização garante
consistência, portabilidade e ampliou ainda mais o alcance da linguagem em diferentes
arquiteturas e sistemas operacionais (KERNIGHAN; RITCHIE, 1988).
Entre as características que consolidaram o sucesso da linguagem C, destacam-se:
● Portabilidade: A capacidade de compilar programas em diferentes sistemas e
arquiteturas tornou C uma linguagem extremamente versátil.
● Simplicidade: A sintaxe direta e acessível permitiu que a linguagem fosse
amplamente utilizada tanto por iniciantes quanto por profissionais experientes.
● Compilação rápida: A geração eficiente de executáveis otimizou o tempo de
desenvolvimento.
● Recursos de baixo nível: A possibilidade de manipulação direta de memória e
hardware eliminou, em muitos casos, a necessidade de programação em
Assembly.
Essas características fizeram da linguagem C uma ferramenta essencial no
desenvolvimento de sistemas, sendo base para linguagens como C++, Java e Python,
consolidando sua relevância na computação moderna.
2.2 Requisitos do Sistema Computacional
A crescente demanda operacional da startup de soluções ambientais, impulsionada
pelo aumento significativo no número de contratos, evidenciou a necessidade de um
sistema computacional robusto e eficiente. Esse sistema tem como objetivo otimizar
tarefas internas, como cadastro de clientes e geração de relatórios, além de atender às
exigências legais e operacionais, como a conformidade com a Lei Geral de Proteção de
Dados (LGPD).
Requisitos Funcionais (RF):
1. Permitir login seguro, garantindo acesso restrito aos usuários autorizados.
2. Facilitar o cadastro completo de indústrias, incluindo informações detalhadas
dos clientes.
3. Possibilitar a atualização mensal de dados relacionados aos resíduos tratados e
custos.
4. Gerar relatórios individualizados e globais baseados nos dados cadastrados.
5. Enviar relatórios para clientes e órgãos governamentais via e-mail ou outro meio.
6. Disponibilizar consulta, edição e exclusão de dados cadastrais, assegurando a
atualização constante do sistema.
7. Permitir a exportação de relatórios em formatos populares, como PDF, Excel e
Word.
8. Gerenciar informações de parceiros da startup, como fornecedores e
consultores.
Requisitos Não Funcionais (RNF):
1. Garantir a segurança e privacidade dos dados, em conformidade com a LGPD.
2. Assegurar a integridade e confiabilidade dos dados e relatórios, prevenindo
inconsistências e perdas.
3. Oferecer acessibilidade e disponibilidade em dispositivos móveis e desktops.
4. Suportar escalabilidade para atender ao aumento do volume de dados e
demandas operacionais.
5. Fornecer uma interface intuitiva e responsiva, otimizando a experiência do
usuário.
A implementação desses requisitos garantirá a entrega de um sistema eficiente, seguro
e adaptado às necessidades específicas da startup.
2.3 Arquitetura e Funcionalidades do Sistema
A arquitetura proposta para o sistema segue o modelo cliente-servidor, estruturada
para garantir uma separação clara entre as funcionalidades de interação com o usuário
e o processamento dos dados.
● Cliente: Representa a interface gráfica do sistema, que permite aos usuários
interagirem com as funcionalidades, como login, cadastro, consultas e geração
de relatórios. A interface inicial foi desenvolvida como um aplicativo desktop,
com possibilidades futuras de expansão para plataformas web ou móveis.
● Servidor: Gerencia as operações realizadas pelo cliente e centraliza o
processamento das informações. Essa estrutura utiliza uma aplicação web para
processar requisições e armazenar dados em bancos de dados, que podem ser
relacionais (MySQL, Oracle) ou não relacionais (MongoDB), dependendo das
necessidades de escalabilidade e performance.
Essa arquitetura proporciona flexibilidade, eficiência e escalabilidade, garantindo que o
sistema atenda tanto às demandas atuais quanto às futuras da startup.
2.4 Tela de Login
A tela de login é uma funcionalidade central para garantir a segurança e o controle de
acesso ao sistema computacional. Ela permite que profissionais da startup autentiquem
suas identidades ao informar um nome de usuário e uma senha previamente
cadastrados. Esse processo de autenticação é fundamental para restringir o uso do
sistema apenas a indivíduos autorizados, protegendo informações sensíveis e
prevenindo acessos não autorizados.
O sistema, ao receber as credenciais, realiza a validação dos dados fornecidos. Essa
validação consiste em comparar as informações inseridas pelo usuário com os
registros armazenados no banco de dados, assegurando que somente pessoas com
permissões adequadas possam acessar as funcionalidades do sistema.
● Login bem-sucedido: Quando as credenciais são validadas com sucesso, o
sistema redireciona o usuário para a tela principal, onde todas as
funcionalidades, como cadastro, consulta e geração de relatórios, estarão
disponíveis. Este fluxo garante uma transição eficiente e orientada às operações
do usuário.
● Login mal-sucedido: Caso as credenciais sejam inválidas, o sistema exibe uma
mensagem de erro informando o usuário sobre a falha no processo de
autenticação. Além disso, solicita que ele tente novamente, permitindo múltiplas
tentativas, mas sempre garantindo que acessos indevidos sejam bloqueados.
Essa funcionalidade é implementada com base nas melhores práticas de segurança. O
uso de autenticação por senha reduz o risco de acesso não autorizado e, quando
combinado com métodos adicionais, como criptografia de dados e logs de acesso,
eleva significativamente o nível de proteção do sistema (PRESSMAN, 2016).
Além disso, o design da tela de login foi projetado para ser intuitivo e de fácil interação,
minimizando a probabilidade de erros por parte dos usuários. Isso está alinhado aos
princípios de usabilidade, que enfatizam a simplicidade e a eficiência na interação entre
o usuário e o sistema (NIELSEN, 1994).
A funcionalidade de login não apenas reforça a segurança do sistema, mas também
garante conformidade com a Lei Geral de Proteção de Dados (LGPD), protegendo
informações sensíveis e assegurando que o acesso ao sistema seja realizado de forma
ética e segura (BRASIL, 2018).
A tela a seguir demonstra a tela de login desenvolvida com código em C representando
o login bem-sucedido.
FIGURA 2 - Tela de Login com os dados de admin
Fonte: Elaboração própria.
A tela a seguir demonstra a tela de login desenvolvida com código em C representando
o login mal-sucedido.
FIGURA 3 - Tela de Login mal-sucedido
Fonte: Elaboração própria.
2.5 Tela de Menu
A tela de menu principal desempenha um papel essencial no sistema, pois centraliza
as funcionalidades disponíveis para os usuários, proporcionando uma navegação
intuitiva e eficiente. Essa interface foi projetada com base nos princípios de usabilidade,
com o objetivo de garantir uma interação clara e objetiva entre o usuário e o sistema
(NIELSEN, 1994). A organização em opções distintas facilita o acesso às funções mais
importantes, otimizando o fluxo de trabalho dos profissionais da startup.
Opções do Menu
1. Cadastrar Indústria Cliente:
Esta funcionalidade permite ao usuário cadastrar um novo cliente, inserindo
informações completas e detalhadas, como dados do responsável, CNPJ,
endereço, e-mail e outras informações essenciais. Essa etapa é fundamentalpara garantir que o sistema possua um banco de dados confiável e atualizado,
servindo de base para as demais operações. O cadastro eficiente de dados é
um dos pilares para a geração de relatórios precisos e análises estratégicas
(PRESSMAN, 2016).
2. Listar Cliente:
Essa funcionalidade permite que o usuário visualize todos os clientes
cadastrados no sistema. Ao selecionar esta opção, o sistema acessa o arquivo
de dados utilizado como banco de dados e exibe uma lista com as informações
completas de cada cliente, como nome da indústria, CNPJ, nome do
responsável, endereço completo, telefone e e-mail. Essa visualização permite
que o usuário consulte os dados diretamente no terminal de forma prática e
sequencial. Atualmente, a listagem de clientes segue a ordem de cadastro,
sendo apresentada na sequência em que os registros foram adicionados ao
sistema. Essa simplicidade reflete o design inicial do sistema, focado em garantir
o acesso básico às informações armazenadas. A funcionalidade cumpre o
objetivo de facilitar a consulta dos registros já cadastrados, contribuindo para o
gerenciamento dos dados e alinhando-se às necessidades operacionais da
startup. Essa funcionalidade reforça o objetivo de manter um banco de dados
acessível e confiável, alinhando-se aos princípios de eficiência e simplicidade,
como proposto por Nielsen (1994).
3. Gerar Relatório Individual:
Com esta opção, o sistema possibilita a geração de relatórios específicos para
uma indústria selecionada. Esses relatórios podem incluir informações
detalhadas, como o total de insumos tratados em um determinado período ou os
custos operacionais mensais. A personalização dos relatórios é essencial para
atender às demandas individuais dos clientes e oferecer insights estratégicos
para a gestão ambiental.
4. Gerar Relatório Global:
Essa funcionalidade fornece uma visão consolidada dos dados de todas as
indústrias cadastradas. Relatórios globais permitem analisar métricas amplas,
como regiões que tratam maior volume de resíduos industriais, indústrias menos
produtivas em determinado período ou aporte financeiro semestral. Esse tipo de
relatório é crucial para decisões estratégicas e alinhamento com políticas
ambientais, atendendo tanto às necessidades da startup quanto de órgãos
regulatórios (BRASIL, 2018).
5. Sair:
A opção de encerrar a sessão garante que o sistema retorne ao ambiente inicial,
preservando a segurança e encerrando o acesso às funcionalidades. Essa
prática é essencial para evitar acessos indevidos, principalmente em sistemas
que lidam com dados sensíveis, como aqueles protegidos pela Lei Geral de
Proteção de Dados (LGPD).
Organização e Usabilidade
A estrutura do menu foi projetada para ser clara e objetiva, promovendo uma
experiência de usuário positiva. Segundo Sommerville (2011), sistemas bem-sucedidos
devem focar em interfaces amigáveis que minimizem a curva de aprendizado dos
usuários e maximizem sua eficiência ao realizar tarefas. A tela de menu reflete esse
princípio ao organizar as funcionalidades de forma hierárquica e facilmente acessível.
Além disso, a inclusão de feedbacks visuais e mensagens claras durante a navegação
reforça a interação usuário-sistema, prevenindo erros e tornando o uso mais intuitivo.
Essa abordagem está alinhada aos princípios de engenharia de software, que
enfatizam a necessidade de projetar sistemas centrados no usuário e focados na
qualidade (PRESSMAN, 2016).
A tela a seguir demonstra a tela de Menu desenvolvida com código em C com 5
opções.
FIGURA 4 - Tela de Menu
Fonte: Elaboração própria.
2.6 Tela de Cadastro
A tela de cadastro é uma funcionalidade crucial para o sistema, pois permite que
profissionais da startup registrem os dados completos de novas indústrias clientes.
Esse registro detalhado é a base para as demais operações do sistema, como
consultas e geração de relatórios. Entre as informações cadastradas, destacam-se:
nome e dados do responsável, nome da empresa, CNPJ, razão social, nome fantasia,
telefone, endereço completo (rua, número, bairro, cidade, estado e CEP), e-mail, data
de abertura.
Validação dos Dados
Uma etapa fundamental no processo de cadastro é a validação das informações
fornecidas. O sistema verifica a consistência dos dados, garantindo que não existam
erros, como campos obrigatórios não preenchidos, formatações incorretas ou
duplicidade de registros. Essa validação é essencial para manter a integridade e a
confiabilidade do banco de dados, reduzindo a possibilidade de falhas ou
inconsistências que possam impactar as operações futuras (PRESSMAN, 2016).
● Cadastro bem-sucedido: Quando os dados fornecidos são validados com
sucesso, o sistema armazena as informações no banco de dados e exibe uma
mensagem de confirmação ao usuário, garantindo que o registro foi concluído
com êxito.
● Cadastro mal-sucedido: Caso o sistema identifique erros, como campos
incompletos ou duplicados, uma mensagem de erro detalhada é exibida,
informando ao usuário os problemas encontrados. O sistema solicita que as
informações sejam corrigidas antes de prosseguir, assegurando que apenas
dados consistentes sejam armazenados.
Importância da Funcionalidade
A funcionalidade de cadastro é essencial para garantir a organização e confiabilidade
das informações no sistema. De acordo com Sommerville (2011), a qualidade de um
sistema de informação está diretamente relacionada à precisão e integridade dos
dados que ele armazena. Assim, a tela de cadastro não apenas facilita o processo de
registro de novas indústrias, mas também contribui para a eficiência das operações,
permitindo consultas rápidas e a geração de relatórios precisos.
Além disso, essa funcionalidade está alinhada às boas práticas de engenharia de
software, que destacam a importância de prever e tratar erros no input de dados,
garantindo que o sistema permaneça robusto e confiável em todas as interações com o
usuário (NIELSEN, 1994).
A implementação de mecanismos de validação e feedback ao usuário, como
mensagens de erro detalhadas, reforça a usabilidade da funcionalidade, garantindo
uma experiência positiva para o profissional da startup.
A tela a seguir demonstra a tela de Cadastro desenvolvida com código em C.
FIGURA 5 - Tela de Cadastro
Fonte: Elaboração própria.
2.7 Tela Listar Cliente
A funcionalidade de listar clientes permite que o usuário visualize, de maneira
organizada, as informações básicas e detalhadas de todas as indústrias cadastradas
no sistema. No código desenvolvido, essa funcionalidade foi implementada para exibir
todos os registros armazenados no arquivo de texto utilizado pelo sistema.
Funcionalidades Disponíveis
1. Exibição de Lista Completa:
Ao acessar a opção de listar clientes no menu, o sistema lê o arquivo onde os
dados das indústrias estão armazenados e exibe as seguintes informações:
Nome do cliente; CNPJ; Endereço completo (rua, número, bairro, cidade,
estado, CEP); E-mail; Telefone; Data de cadastro.
2. Essa exibição é feita de forma sequencial, com base na ordem em que os
registros foram adicionados ao arquivo.
3. Consulta Simples:
A funcionalidade é direta e apresenta os dados completos de cada cliente no
terminal, sem opções de interação adicional, como detalhamento individual ou
exportação.
4. Validação de Dados no Arquivo:
O sistema valida a existência de registros antes de realizar a listagem. Caso o
arquivo esteja vazio ou corrompido, uma mensagem informativa é exibida para o
usuário, garantindo que a execução do programa continue sem falhas.
A tela a seguir demonstra a tela Listar cliente desenvolvida com código em C.
FIGURA 6 - Tela de Listar clientes
Fonte: Elaboração própria.
2.8 Relatório Individual / Global
O código implementado permite a geração de relatórios básicos a partir dos dados
cadastrados no sistema. No formato atual, os relatórios são gerados de forma
sequencial e exibem as informações armazenadas no arquivo utilizado como banco de
dados simples. A funcionalidade contempla os seguintes tipos de relatórios:
● Relatório Individual: Inclueminformações específicas de um cliente, como o
nome da indústria/cliente, o total de insumos tratados e os gastos mensais. O
relatório é gerado a partir dos registros cadastrados no sistema e exibido
diretamente no terminal e também gerado um arquivo TXT.
● Relatórios Globais: Apresenta uma visão consolidada, do total de clientes, total
de resíduos tratados e total de custos estimados. O relatório é gerado a partir
dos registros cadastrados no sistema e exibido diretamente no terminal e
também gerado um arquivo TXT.
A funcionalidade de geração e exibição de relatórios cumpre o propósito básico de
fornecer informações registradas no sistema.
A tela a seguir demonstra a tela Relatório Individual com cliente a busca bem sucedida
desenvolvida com código em C.
FIGURA 7 - Tela de Relatório Individual
Fonte: Elaboração própria.
A tela a seguir demonstra a tela Relatório Individual com a busca mal-sucedida
desenvolvida com código em C.
FIGURA 8 - Tela de Relatório Individual mal-sucedido
Fonte: Elaboração própria.
A tela a seguir demonstra a tela Relatório Global com geração de TXT desenvolvida
com código em C.
FIGURA 9 - Tela de Relatório Global
Fonte: Elaboração própria.
2.9. Programa em Linguagem em C
O código desenvolvido implementa funcionalidades essenciais, como autenticação por
login, registro detalhado de clientes, aplicação de criptografia básica para proteger
informações sensíveis e exibição de uma listagem completa dos clientes cadastrados.
Segue o código.
#include 
#include 
#include 
// Estruturas de dados para armazenar informações de clientes
typedef struct {
char nome_responsavel[100];
char nome_empresa[100];
char cnpj[20];
char razao_social[100];
char nome_fantasia[100];
char telefone[15];
char endereco[200];
char email[100];
char data_abertura[12];
double residuos_tratados;
double custo_estimado;
} Cliente;
// Função para criptografar dados sensíveis (simples substituição de caracteres)
void criptografar(char *texto) {
for (int i = 0; texto[i] != '\0'; i++) {
texto[i] += 3; // Substituição básica de caracteres
}
}
// Função para descriptografar dados sensíveis
void descriptografar(char *texto) {
for (int i = 0; texto[i] != '\0'; i++) {
texto[i] -= 3;
}
}
// Função para realizar login
int login() {
char usuario[50], senha[50];
printf("Digite o usuario: ");
scanf("%s", usuario);
printf("Digite a senha: ");
scanf("%s", senha);
// Login simples (usuário e senha fixos para demonstração)
if (strcmp(usuario, "fabianamcosta") == 0 && strcmp(senha, "1234") == 0) {
return 1; // Login bem-sucedido
} else {
printf("Usuario ou senha incorretos!\n");
return 0; // Falha no login
}
}
// Função para cadastrar um cliente
void cadastrarCliente() {
FILE *arquivo;
Cliente cliente;
// Abrindo arquivo para gravação
arquivo = fopen("clientes.txt", "a");
if (arquivo == NULL) {
printf("Erro ao abrir arquivo!\n");
return;
}
printf("\nDigite o nome do responsável: ");
fgets(cliente.nome_responsavel, sizeof(cliente.nome_responsavel), stdin);
strtok(cliente.nome_responsavel, "\n"); // Remove o '\n' final
printf("\nDigite o nome da empresa: ");
fgets(cliente.nome_empresa, sizeof(cliente.nome_empresa), stdin);
strtok(cliente.nome_empresa, "\n");
printf("Digite o CNPJ: ");
fgets(cliente.cnpj, sizeof(cliente.cnpj), stdin);
strtok(cliente.cnpj, "\n");
printf("Digite a razão social: ");
fgets(cliente.razao_social, sizeof(cliente.razao_social), stdin);
strtok(cliente.razao_social, "\n");
printf("Digite o nome fantasia: ");
fgets(cliente.nome_fantasia, sizeof(cliente.nome_fantasia), stdin);
strtok(cliente.nome_fantasia, "\n");
printf("Digite o telefone com (DDD): ");
fgets(cliente.telefone, sizeof(cliente.telefone), stdin);
strtok(cliente.telefone, "\n");
printf("\nDigite o endereço completo (com nome da rua/avenida, número e
complemento, cep, cidade e estado): ");
fgets(cliente.endereco, sizeof(cliente.endereco), stdin);
strtok(cliente.endereco, "\n");
printf("\nDigite o email: ");
fgets(cliente.email, sizeof(cliente.email), stdin);
strtok(cliente.email, "\n");
printf("Digite a data de abertura (dd/mm/aaaa): ");
fgets(cliente.data_abertura, sizeof(cliente.data_abertura), stdin);
strtok(cliente.data_abertura, "\n");
printf("Digite a quantidade de resíduos tratados: ");
scanf("%lf", &cliente.residuos_tratados);
getchar(); // Consumir o '\n' restante
printf("Digite o custo estimado: ");
scanf("%lf", &cliente.custo_estimado);
getchar();
// Criptografar informações sensíveis antes de salvar
criptografar(cliente.cnpj);
criptografar(cliente.email);
// Gravando dados no arquivo
fwrite(&cliente, sizeof(Cliente), 1, arquivo);
printf("Cliente cadastrado com sucesso!\n");
fclose(arquivo);
}
// Função para listar todos os clientes
void listarClientes() {
FILE *arquivo;
Cliente cliente;
// Abrindo arquivo para leitura
arquivo = fopen("clientes.txt", "r");
if (arquivo == NULL) {
printf("Nenhum cliente cadastrado!\n");
return;
}
printf("Lista de clientes cadastrados:\n");
while (fread(&cliente, sizeof(Cliente), 1, arquivo)) {
// Descriptografar informações sensíveis antes de exibir
descriptografar(cliente.cnpj);
descriptografar(cliente.email);
printf("---------------------------------\n");
printf("Nome do responsavel: %s\n", cliente.nome_responsavel);
printf("Nome da empresa: %s\n", cliente.nome_empresa);
printf("CNPJ: %s\n", cliente.cnpj);
printf("Email: %s\n", cliente.email);
printf("Endereco: %s\n", cliente.endereco);
printf("Residuos tratados: %.2lf\n", cliente.residuos_tratados);
printf("Custo estimado: %.2lf\n", cliente.custo_estimado);
}
fclose(arquivo);
}
// Função para gerar relatório individual
void gerarRelatorioIndividual() {
FILE *arquivo;
FILE *relatorio; // Ponteiro para o arquivo de relatório
Cliente cliente;
char cnpj[20];
int encontrado = 0;
getchar(); // Consumir '\n' residual do buffer
printf("Digite o CNPJ: ");
fgets(cnpj, sizeof(cnpj), stdin);
strtok(cnpj, "\n"); // Remove o caractere '\n' do final da string
criptografar(cnpj);
// Abrir o arquivo de clientes para leitura
arquivo = fopen("clientes.txt", "r");
if (arquivo == NULL) {
printf("Nenhum cliente cadastrado!\n");
return;
}
// Abrir o arquivo de relatório individual para escrita
relatorio = fopen("relatorio_individual.txt", "w");
if (relatorio == NULL) {
printf("Erro ao criar o arquivo de relatório!\n");
fclose(arquivo);
return;
}
while (fread(&cliente, sizeof(Cliente), 1, arquivo)) {
if (strcmp(cliente.cnpj, cnpj) == 0) {
encontrado = 1;
descriptografar(cliente.cnpj);
descriptografar(cliente.email);
// Exibir o relatório no console
printf("Relatório Individual:\n");
printf("Nome da empresa: %s\n", cliente.nome_empresa);
printf("Resíduos tratados: %.2lf\n", cliente.residuos_tratados);
printf("Custo estimado: %.2lf\n", cliente.custo_estimado);
// Escrever o relatório no arquivo TXT
fprintf(relatorio, "Relatório Individual:\n");
fprintf(relatorio, "Nome do responsável: %s\n", cliente.nome_responsavel);
fprintf(relatorio, "Nome da empresa: %s\n", cliente.nome_empresa);
fprintf(relatorio, "CNPJ: %s\n", cliente.cnpj);
fprintf(relatorio, "Email: %s\n", cliente.email);
fprintf(relatorio, "Endereço: %s\n", cliente.endereco);
fprintf(relatorio, "Resíduos tratados: %.2lf\n", cliente.residuos_tratados);
fprintf(relatorio, "Custo estimado: %.2lf\n", cliente.custo_estimado);
fprintf(relatorio, "---------------------------------\n");
break;
}
}
if (!encontrado) {
printf("Cliente não encontrado.\n");
fprintf(relatorio, "Cliente não encontrado para o CNPJ fornecido.\n");
}
fclose(arquivo);
fclose(relatorio);
if (encontrado) {
printf("Relatório individual salvo em 'relatorio_individual.txt'.\n");
}
}
// Função para gerar relatório global
void gerarRelatorioGlobal() {
FILE *arquivo;
FILE *relatorio; // Ponteiro para o arquivo de relatório
Cliente cliente;
double totalResiduos = 0;
double totalCustos = 0;
int totalClientes = 0;
//Abrir o arquivo de clientes para leitura
arquivo = fopen("clientes.txt", "r");
if (arquivo == NULL) {
printf("Nenhum cliente cadastrado!\n");
return;
}
// Abrir o arquivo de relatório global para escrita
relatorio = fopen("relatorio_global.txt", "w");
if (relatorio == NULL) {
printf("Erro ao criar o arquivo de relatório global!\n");
fclose(arquivo);
return;
}
// Ler os dados de cada cliente e calcular os totais
while (fread(&cliente, sizeof(Cliente), 1, arquivo)) {
totalResiduos += cliente.residuos_tratados;
totalCustos += cliente.custo_estimado;
totalClientes++;
}
// Exibir o relatório no console
printf("Relatório Global:\n");
printf("Total de clientes: %d\n", totalClientes);
printf("Total de resíduos tratados: %.2lf\n", totalResiduos);
printf("Total de custos estimados: %.2lf\n", totalCustos);
// Escrever o relatório no arquivo TXT
fprintf(relatorio, "Relatório Global:\n");
fprintf(relatorio, "Total de clientes: %d\n", totalClientes);
fprintf(relatorio, "Total de resíduos tratados: %.2lf\n", totalResiduos);
fprintf(relatorio, "Total de custos estimados: %.2lf\n", totalCustos);
// Fechar os arquivos
fclose(arquivo);
fclose(relatorio);
printf("Relatório global salvo em 'relatorio_global.txt'.\n");
}
// Função principal
int main() {
int opcao;
if (!login()) {
return 0;
}
do {
printf("\nMenu:\n");
printf("1. Cadastrar cliente\n");
printf("2. Listar clientes\n");
printf("3. Gerar relatório individual\n");
printf("4. Gerar relatório global\n");
printf("5. Sair\n");
printf("Digite sua opcao: ");
scanf("%d", &opcao);
switch (opcao) {
case 1:
cadastrarCliente();
break;
case 2:
listarClientes();
break;
case 3:
gerarRelatorioIndividual();
break;
case 4:
gerarRelatorioGlobal();
break;
case 5:
printf("Saindo...\n");
break;
default:
printf("Opcao invalida!\n");
}
} while (opcao != 5);
return 0;
}
2.10. Compilação do Programa
Após abrir o programa no Code::Blocks, deve clicar em Build -> Compile current
file. Na janela de log abaixo do programa, haverá a indicação de que o programa
foi compilado com sucesso: 0 errors, 0 warnings. A tela a seguir demonstra a tela da
aplicação CodeBlocks.
FIGURA 10 - Tela da aplicação CodeBlocks
Fonte: Elaboração própria.
A tela a seguir demonstra a pasta com os binários e documentos do projeto.
FIGURA 11 - Tela do projeto no explorer windows
Fonte: Elaboração própria.
Com base no projeto, segue a lista dos materiais relacionados à documentação e
suporte ao sistema como Arquivos-fontes (desenvolvidos em Linguagem C -
Code::Blocks) e Binários do programa (exe, dlls, arquivos de teste, arquivo de
configuração).
Documentação do Sistema
● Fluxo da Jornada:
○ Inclui as interações entre os usuários e as funcionalidades do sistema.
○ Representa o fluxo de trabalho desde o login até a geração de relatórios.
● Manual do Usuário:
○ Introdução e funcionalidades principais.
○ Passo a passo para utilizar o sistema, incluindo telas de exemplo.
● Manual de Instalação:
○ Requisitos de hardware e software.
○ Procedimentos para instalar o sistema em Windows e Linux.
● Instruções para Compilação:
○ Ferramentas necessárias (ex.: Code::Blocks).
○ Comandos de compilação e linkagem.
● Guia de Testes:
○ Estratégias de teste unitário e de integração.
○ Casos de teste específicos para validar cada funcionalidade.
Arquivos Incluídos:
● Arquivos Word para os manuais e diagramas.
● Código-fonte em C e scripts de configuração.
Planilha de Testes - QA.
● Arquivo em excel constando os resultados de testes de QA.
Os materiais estão disponibilizados em um arquivo ‘projeto.zip’.
3. CONCLUSÃO
A intervenção proposta neste trabalho teve como objetivo o desenvolvimento de
estratégias para a criação de um software de cadastramento de clientes para uma
startup de soluções ambientais. Utilizando a linguagem C, foi possível implementar as
funcionalidades essenciais do sistema, incluindo o cadastro de clientes, a geração de
relatórios individualizados e globais, e a segurança dos dados, com base na
criptografia de informações sensíveis em conformidade com a LGPD.
O desenvolvimento foi realizado no IDE Code::Blocks, onde foram implementadas as
linhas de código necessárias para estruturar o sistema, desde a tela de login até
funcionalidades que permitem ao usuário consultar, editar e atualizar os dados
cadastrados. O software também suporta relatórios detalhados, essenciais para a
análise e gestão eficiente dos dados ambientais, atendendo às demandas operacionais
e estratégicas da startup.
Além disso, o projeto utilizou fundamentos das disciplinas de Linguagem e Técnicas de
Programação e Engenharia de Software I, integrando conhecimentos teóricos e
práticos. Durante o desenvolvimento, as metodologias foram avaliadas para identificar
pontos fortes e fracos, culminando na adoção do Modelo Cascata. Essa escolha se
mostrou adequada, pois a abordagem sequencial proporcionou maior organização e
clareza na execução das etapas do projeto, desde o levantamento de requisitos até os
testes e refinamentos.
A aplicação prática deste software destaca a importância do planejamento e da escolha
de ferramentas e metodologias apropriadas para o desenvolvimento de soluções
tecnológicas que atendam às demandas de mercado. O sistema não apenas otimiza as
operações da startup, mas também contribui para um gerenciamento mais eficaz de
dados ambientais, reforçando seu papel como uma ferramenta estratégica tanto para a
empresa quanto para seus clientes e órgãos reguladores.
Por fim, o trabalho demonstrou como a combinação de linguagem de programação,
metodologias de desenvolvimento e requisitos de segurança pode resultar em um
sistema robusto, eficiente e escalável, pronto para atender às necessidades de uma
organização em crescimento. Essa experiência reforça a importância de alinhar teoria e
prática no desenvolvimento de soluções que impactam diretamente a sustentabilidade
e a eficiência empresarial. Os demais Arquivos-fontes (desenvolvidos em Linguagem C
- Code::Blocks) e Binários do programa (exe, dlls, arquivos de teste, arquivo de
configuração) estão disponíveis em um arquivo ‘projeto.zip’.
Para desenvolvimentos de novas funcionalidades futuras, caberia gerar cada vez mais
valor nesse cadastro pensando em ajustes para a edição e atualização de cadastros,
busca com filtros para a lista de clientes, envio dos relatórios gerados para um email
específico ou um conjunto de emails, entre outros elementos que podem ser pensados
com apoio dos usuários do sistema para elencar os benefícios.
REFERÊNCIAS
BRASIL. Lei Geral de Proteção de Dados Pessoais (LGPD), Lei nº 13.709, de 14 de
agosto de 2018. Disponível em:
http://www.planalto.gov.br/ccivil_03/_ato2015-2018/2018/lei/l13709.htm. Acesso em: 14
nov. 2024.
KERNIGHAN, B.; RITCHIE, D. The C Programming Language. 2. ed. Englewood
Cliffs: Prentice Hall, 1988.
MANZANO, J. A. N. G. Estudo dirigido de linguagem C. 17. ed. São Paulo: Érica,
2013.
NIELSEN, J. Usability Engineering. San Francisco: Morgan Kaufmann, 1994.
PRESSMAN, R. S. Engenharia de Software: Uma abordagem profissional. 7. ed.
São Paulo: McGraw Hill, 2016.
RITCHIE, D. M. The development of the C language. Bell Labs Technical Journal, v.
7, n. 1, p. 31-41, 1988.
ROYCE, W. W. Managing the Development of Large Software Systems. Proceedings of
IEEE WESCON, 1970.
SEBESTA, R. W. Concepts of Programming Languages. 10. ed. Boston: Pearson,
2012.
WIRTH, N. The Programming Language Pascal. Acta Informatica, v. 1, p. 35-63,
1976.
SOMMERVILLE, I. Software Engineering. 9. ed. Boston: Pearson, 2011.