pontifícia universidade católica do paraná centro de

Transcrição

PONTIFÍCIA UNIVERSIDADE CATÓLICA DO PARANÁ
CENTRO DE CIÊNCIAS EXATAS E DE TECNOLOGIA
ENGENHARIA DE COMPUTAÇÃO
PROJETO CHUVEIRO INTELIGENTE
CURITIBA
2009
CARLOS ROBERTO REMENCHE JUNIOR
DENIS REIMCHE OTT
RAFAEL ANTÔNIO GROSKO
PROJETO CHUVEIRO INTELIGENTE
Este projeto será apresentado às
disciplinas o Curso de Engenharia de
Computação
do Centro de Ciências
Exatas e de Tecnologia da Pontifícia
Universidade Católica do Paraná, como
parte integrante da nota do primeiro
semestre. A finalidade deste projeto é
integração das diversas disciplinas do
curso.
Professores orientadores: Gil
Jess e Afonso Ferreira Miguel.
CURITIBA
2009
Marcos
Índice
1 - INTRODUÇÃO...................................................................................................................................4
1.1- JUSTIFICATIVAS............................................................................................................................5
1.2 - METODOLOGIA.....................................................................................................................6
2 – RESPONSABILIDADES............................................................................................................7
3 – OBJETIVOS.............................................................................................................................8
3.1 – NÃO ESTÁ INCLUSO NO ESCOPO DO PROJETO.................................................................9
4 - EQUIPE DE DESENVOLVIMENTO............................................................................................10
5 - O PROJETO............................................................................................................................11
5.1 – CÓDIGO-FONTE.........................................................................................................................14
5.2 – POSTAGENS NO WEBSITE.......................................................................................................32
6 – CONCLUSÃO.................................................................................................................................57
1. INTRODUÇÃO
A matéria projeto integrado do curso de Engenharia de Computação ministrada pelo
professor Afonso Ferreira Miguel tem o intuito de preparar e aperfeiçoar a mentalidade do
engenheiro que não se voltará somente pesquisa de novas tecnologias, mas sim o
desenvolvimento de novas soluções para algumas adversidades, tentando por a natureza a
serviço do homem, podendo explorar tudo que ela pode oferecer.
O grupo atual foi formado para o estudo e Projeto Integrado do terceiro período do
curso é formado pelos seguintes integrantes: Carlos Roberto Remenche Junior, Denis
Reimche Ott, Rafael Antônio Grosko.
A idéia do projeto surgiu quando o integrante Denis Reimche Ott, durante especulações
lúdicas de como poderias transformar o celular como um controle universal, falou-se de
ligar o chuveiro pelo celular e controlar a temperatura e vazão pelo mesmo, idéia acatada
com entusiasmo e otimismo pelos demais. Ficou claro que havia um problema, a falta de
controle que temos sobre o chuveiro, que poderia e deveria ser sanada.
1.1. JUSTIFICATIVAS
O projeto “Chuveiro Inteligente” foi desenvolvido para otimizar um costume comum de
todos, o banho diário. Mudando o modo que o usuário se relaciona com seu chuveiro.
Nosso projeto visa facilitar o banho tornando-o mais simplificado, retirando válvulas e
controles manuais difíceis de serem ajustados transportando-os para um controle digital,
computadorizando-os, responsabilizando o computador pela temperatura e vazão desejada.
Pesquisando o estado da arte, alguns produtos interessantes vêm alguns que apenas
se preocupam com a parte estética e não tem como objetivo de criar um banho mais
inteligente. Como se não fosse o custo básico de um chuveiro deste tipo é muito elevado,
passando facilmente de R$ 1.000,00 (mil reais) sendo somente acessível para a classe alta.
O “Chuveiro Inteligente” tem como objetivo criar uma solução simples, barata, e com o
objetivo de ampliar o controle e utilização do chuveiro. O sistema utilizado consiste em um
chuveiro eletrônico com potenciômetro regulável que é acionado por meio de um motor de
passo. A vazão é controlada por duas válvulas solenóides. A leitura da temperatura da água
é feita em dois pontos, e com essa temperatura o banho é ajustado automaticamente. A
interface com o computador por se da por meio de uma porta USB onde um programa em
linguagem C++ controla todo o sistema.
1.2 - METODOLOGIA
O método usado para desenvolver o “Chuveiro Inteligente” consistiu em uma pesquisa
sobre os módulos a serem implementados no circuito, como seria a melhor maneira de
controlar a água e temperatura, um Web Site foi colocado no ar com informações do
projeto e no decorrer do mesmo foi atualizado semanalmente com histórias, diagramas,
fotos,
curiosidades
e
tudo
que
o
envolve.
O
site
do
projeto
é
www.chuveirointeligente.blogspot.com.
Nas primeiras semanas foi comprado o material para a montagem do circuito elétrico,
em primeiro momento em proto-board, para aprender e verificar o funcionamento e
verificar a montagem adequada do circuito para evitar erros como curto circuitos.
Nas seguintes semanas, com todo o circuito montado em proto-board, foi dado
inicio ao desenho dos circuitos, para serem impressos nas placas de maneira mais segura
e profissional, usando o programa Eagle, assim como também foi iniciado os estudos da
linguagem a ser utilizada para a programação. Com os desenhos das placas prontos
começou a fabricação das placas de circuito impresso. Com as placas corroídas e com
as trilhas perfeitas, foram colocados os componentes soldando-os nas placas. Com os
circuitos prontos e testados para evitar curtos entre as trilhas, testamos o funcionamento
de todo o circuito junto com todos os componentes adicionais (sensores, válvulas
solenóides, servo motores).
Com os circuitos prontos, a programação foi o foco central do trabalho, só restava
à montagem da estrutura, que foi iniciada na semana seguinte. Com a aquisição dos
materiais necessários, foi montada a estrutura e realizados alguns testes para verificar o
funcionamento de tudo produzido até o momento, descobrimos que o peso do chuveiro
com a água seria pesado demais para a estrutura, foram feitas diversas modificações
para torná-lo mais forte. Com ela pronta foi projetada a parte hidráulica, que logo foi
concluída com a aquisição dos materiais necessários e montagem, colocando as válvulas
solenóide. Tivemos que substituir uma válvula solenóide por uma bomba de combustível
de carro, para aumentar a vazão para suprir a quantidade de água que o chuveiro
necessita.
Após a conclusão dessas etapas ainda restava o programa, que já estava em fase
final, faltando alguns ajustes e testes. No programa, foram enfrentados muitos problemas,
tanto pelo estudo da linguagem, que é o C++ em Windows Form usando o Visual Studio,
quanto pelo código utilizado. Com todos os ajustes feitos, os problemas foram resolvidos
e o programa ficou pronto.
Concluindo assim a montagem e implementação do projeto “Chuveiro Inteligente”.
2 – RESPONSABILIDADES
Para a criação e desenvolvimento do projeto foi necessária a dedicação de todos os
integrantes do grupo, assim como dos professores. Cada integrante do projeto teve que
realizar sua parte com vontade e comprometimento para que o projeto cria-se forma e
fosse assim concluído. A PUC, com estrutura laboratorial e funcionários dedicados foram
parte fundamental para o desenvolvimento e amadurecimento contínuo do mesmo.
3 – OBJETIVOS
O projeto “Chuveiro Inteligente” teve como objetivo, o aprendizado sobre pesquisas,
documentações, cronogramas, apresentações, ou seja, tudo que envolve um adequado
gerenciamento de projeto, assim como utilizar conhecimentos recebidos em sala de
aula já em aplicações mais próximas da engenharia propriamente dita, como a
utilização dos conceitos de circuitos elétricos e sistemas digitais para uma interpretação
real das tecnologias empregadas no projeto. Como circuitos elétricos e sistemas digitais
que foram exaustivamente revisadas e aplicadas durante o mesmo.
Sem relevar a oportunidade de poder desenvolver algo que aumente o conforto do
usuário durante o banho. Haveria economia de água e energia, se o usuário
consegui-se atingir a temperatura de banho que ele julga-se adequada mais rápido,
dispensado aquele clássico ritual de “calibração” da temperatura e quantidade todas
vez antes do banho, que em alguns casos é relativamente demorada, ou seja, fosse
capaz
de
automaticamente
regular
temperatura
temperaturas previamente escolhidas pelo usuário.
com
base
nas
leituras
de
3.1 – NÃO ESTÁ INCLUSO NO ESCOPO DO PROJETO
Poderiam ser incluídas diversas funcionalidades no nosso projeto, como um contador de
quantidade de água vazante, de energia utilizada, um monitor touch-screen de pequena
escala para ser usado como interface usuário-máquina, entre vários outros, é sem dúvida
um projeto muito fértil para quem quer proporcionar conforto e controle total durante o
banho. Não foram implementados neste projeto, pois dependeria de muito mais tempo, pois
um semestre foi insuficiente nos condenando a uma superficialidade do todo que poderia
ser, estudo de novas possibilidades e custos por parte do grupo.
4 - EQUIPE DE DESENVOLVIMENTO
A equipe de desenvolvimento contou com Carlos Roberto Remenche Junior, Denis Reimche
Ott, Rafael Antônio Grosko.Pontes que foram responsáveis por realizar determinadas
tarefas específicas. As tarefas foram distribuídas da seguinte maneira:
Carlos Roberto Remenche Junior:
-Estruturação e atualização do blog
-Documentação
-Testes finais
Denis Reimche Ott
-Montagem do circuito em Proto-Board
-Documentação
-Auxílio na programação
-Montagem e manutenção das placas e cabos
Rafael Antonio Grosko
-Montagem do circuito em Proto-Board
-Programação
-Montagem dos circuitos
-Auxílio na montagem da estrutura
-Testes finais
5 - O PROJETO
O projeto foi constituído de três fases: HARDWARE, ESTRUTURA HIDRÁULICA,
PROGRAMAÇÃO.
A parte do Hardware foram utilizadas para implementar a comunicação e controle
via software entre o computador e as válvulas, sensor e motor. Foi utilizado primariamente,
para realizar a comunicação computador<->módulos, o conversor RS 232-TTL que utiliza
uma entrada serial pra comunicação com o computador. Para o controle das válvulas,
sensor e motor servo foram utilizados módulos específicos (M2 e M1). Todos módulos
foram construídos através dos esquemáticos disponibilizados pelo professor Afonso. Foram
ainda utilizados etapas de potência para garantir a correta voltagem no sistema e um
transformador de 110V para 15V que serve como fonte de alimentação elétrica para o
sistema. As placas e a fonte foram acomodados em uma caixa de plástico própria para
circuitos para melhor organização, transporte e apresentação do sistema.
A estrutura hidráulica consiste em uma placa de madeira(MDF) em formato de U
que serve como base principal para o projeto. Outra placa de madeira, retirada da placa
inicial, foi presa à base, em posição vertical, para dar suporte ao chuveiro. Toda a parte
hidráulica, válvulas de controle, caixa com as placas de circuito foi anexada à essa
estrutura.
Como ilustra a foto, foi utilizada uma tubulação padrão de PVC em conjunto com
mangueiras de silicone para melhor visualização do movimento da água. O sistema recebe
a alimentação de água por meio de uma torneira normal com vazão suficiente para ligar o
chuveiro. Por meio de uma mangueira essa água chega a parte hidráulica do projeto, em
uma conexão em formato T a água é dívida em duas tubulações, uma para cada válvula,
depois de passar pelas válvulas a água chega a outra conexão em T que une as duas
tubulações. Essa última tubulação sobe pela placa vertical da base, chegando ao topo da
placa foi colocada uma curva de 90° (joelho) de PVC para o cano ficar na posição horizontal
e servir de fixação para o chuveiro eletrônico.
O chuveiro utilizado foi um chuveiro eletrônico da marca Zagonel, que utiliza um
controle de temperatura manual por meio de um potenciômetro, este utiliza uma fiação para
se ligar ao chuveiro, podendo assim ser fixado em qualquer posição próxima ao chuveiro.
Por ter essa facilidade de mobilidade do potenciômetro este chuveiro foi escolhido para o
projeto.
Duas válvulas solenóides (ou eletro-válvulas) foram utilizadas para o controle da
vazão da água. Essas válvulas operam de modo simples, elas em seu interior contém um
eletro-imã fixo, um pedaço de metal é preso a uma parte móvel que corre por dentro de um
pequeno vão dentro da válvula. Se a válvula é alimentada com a voltagem correta, esse
eletro-imã entra em ação atraindo o pedaço de metal, puxando assim juntamente a parte
plástica liberando assim passagem de água. Se não existir a alimentação elétrica, o pedaço
de metal não é atraído e por meio de uma mola, a válvula permanece fechada. As válvulas
foram fixadas na tubulação, servindo esta como suporte, de forma que as válvulas poderiam
ser utilizadas em conjunto ou separadas. A tubulação antes e depois de cada válvula foi
substituída por pedaços de mangueira de silicone transparente para facilitar a conexão com
as válvulas e visualização da passagem de água. A primeira válvula ,de material metálico,
foi retirada de um sistema de ar de um caminhão. Utiliza 12V para operar. Pela tubulação
ser de PVC e a válvula ser metálica houve certa dificuldade em adaptar ela ao conjunto. A
segunda válvula, de plástico e suporte em metal, foi retirada de uma máquina de lavar. Ela
opera com 110V, necessitando assim de uma alimentação direta da rede elétrica. Para
controlá-la foi utilizado um relé que é acionado com 12V, podendo este ser integrado
facilmente aos circuitos previamente discutidos.
Para o controle de temperatura foi utilizado o potenciômetro original do chuveiro,
este foi ligado à um motor servo e ambos foram presos com madeira à base principal. O
potenciômetro consiste em uma pequena caixa, ligado ao chuveiro por um cabo elétrico,
com um dispositivo que ao ser girado modifica sua resistência deixando passar mais ou
menos corrente, ou seja, ao ser girado modifica a potência que o chuveiro tem para aquecer
a água, mudando assim a temperatura da água que o chuveiro fornece. Para controlar este
dispositivo foi utilizado um motor servo. O motor usado foi obtido do sistema de controle de
polarização de uma antena parabólica. Este motor tem como característica o controle
preciso de seus movimentos, ideal para controlar um pequeno dispositivo como o
potenciômetro. Ele funciona com um controle vindo do módulo e gira de acordo com o
comando fornecido, controlando assim o potenciômetro.
Para verificar a temperatura, foi utilizado um sensor acoplado ao chuveiro. Este
sensor é ligado ao circuito para leitura da temperatura da água no chuveiro.
Todo o controle é feito via software ligado ao sistema pelo módulo de conversão
RS 232-TTL discutido previamente. O computador foi ligado ao sistema por um conversor
USB-Serial pela comodidade que existe em usar a porta USB. O software foi desenvolvido
em plataforma Windows, utilizando o programa Visual Studio, ambos da empresa Microsoft.
A linguagem de programação utilizada foi o C++. Foi utilizado ainda o Windows Form para
facilitar o geração da parte gráfica do programa. Este programa será melhor discutido em
outro item.
5.1 – CÓDIGO-FONTE
form1.h
#include <windows.h>
#pragma once
namespace ChuveiroInteligente {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
/// <summary>
/// Summary for Form1
///
/// WARNING: If you change the name of this class, you will need to change
the
///
'Resource File Name' property for the managed resource compiler
tool
///
associated with all .resx files this class depends on. Otherwise,
///
the designers will not be able to interact properly with localized
///
resources associated with this form.
/// </summary>
public ref class Form1 : public System::Windows::Forms::Form
{
public:
Form1(void)
{
InitializeComponent();
//
//TODO: Add the constructor code here
//
}
protected:
/// <summary>
/// Clean up any resources being used.
/// </summary>
~Form1()
{
if (components)
{
delete components;
}
}
private: System::Windows::Forms::Button^ button1;
protected:
private: System::Windows::Forms::NumericUpDown^ numericUpDown1;
private: System::Windows::Forms::Label^ label1;
private: System::IO::Ports::SerialPort^ serial;
private: System::Windows::Forms::Timer^ timer1;
private:
private: System::ComponentModel::IContainer^ components;
private:
/// <summary>
/// Required designer variable.
/// </summary>
#pragma region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
void InitializeComponent(void)
{
this->components
=
(gcnew
System::ComponentModel::Container());
System::ComponentModel::ComponentResourceManager^
resources
=
(gcnew
System::ComponentModel::ComponentResourceManager(Form1::typeid));
this->button1 = (gcnew System::Windows::Forms::Button());
this->numericUpDown1
=
(gcnew
=
(gcnew
System::Windows::Forms::NumericUpDown());
this->label1 = (gcnew System::Windows::Forms::Label());
this->serial
=
(gcnew
System::IO::Ports::SerialPort(this-
>components));
this->timer1 = (gcnew System::Windows::Forms::Timer(this>components));
=
(gcnew
(cli::safe_cast<System::ComponentModel::ISupportInitialize^
>(this->numericUpDown1))->BeginInit();
this->SuspendLayout();
//
// button1
//
resources->ApplyResources(this->button1, L"button1");
this->button1->Name = L"button1";
this->button1->UseVisualStyleBackColor = true;
this->button1->Click
+=
gcnew
System::EventHandler(this,
&Form1::button1_Click);
//
// numericUpDown1
//
resources->ApplyResources(this->numericUpDown1,
L"numericUpDown1");
this->numericUpDown1->Maximum = System::Decimal(gcnew
cli::array< System::Int32 >(4) {50, 0, 0, 0});
this->numericUpDown1->Minimum = System::Decimal(gcnew
this->numericUpDown1->Name = L"numericUpDown1";
this->numericUpDown1->Value
=
System::Decimal(gcnew
//
// numericUpDown2
//
L"numericUpDown2");
this->numericUpDown2->Maximum = System::Decimal(gcnew
this->numericUpDown2->Minimum = System::Decimal(gcnew
this->numericUpDown2->Value
=
System::Decimal(gcnew
//
// label1
//
resources->ApplyResources(this->label1, L"label1");
this->label1->ForeColor
=
System::Drawing::SystemColors::HotTrack;
this->label1->Name = L"label1";
//
// label2
//
this->label2->ForeColor
=
System::Drawing::SystemColors::HotTrack;
//
// serial
//
this->serial->BaudRate = 1200;
this->serial->PortName = L"COM5";
//
// timer1
//
this->timer1->Enabled = true;
this->timer1->Interval = 600000;
//
// label3
//
//
// button2
//
+=
gcnew
//
// button3
//
+=
gcnew
//
// button4
//
+=
gcnew
//
// numericUpDown3
//
L"numericUpDown3");
this->numericUpDown3->Increment = System::Decimal(gcnew
this->numericUpDown3->TabStop = false;
//
// Form1
//
resources->ApplyResources(this, L"$this");
this->AutoScaleMode
System::Windows::Forms::AutoScaleMode::Font;
this->Controls->Add(this->numericUpDown3);
this->Controls->Add(this->button4);
this->Controls->Add(this->label3);
=
this->ForeColor = System::Drawing::SystemColors::HotTrack;
this->Name = L"Form1";
this->Opacity = 0.94;
>(this->numericUpDown1))->EndInit();
this->ResumeLayout(false);
this->PerformLayout();
}
#pragma endregion
private:
System::Void
button1_Click(System::Object^
sender,
System::EventArgs^ e) {
if(serial->IsOpen == false){
serial->Open();
//funcao para leitura de lixo
int cont;
//Liga o motor servo
serial->WriteLine("\rcim1.pwm.T=96\r");
cont+=3;
Sleep(300);
serial->WriteLine("\rcim1.pwm0.on(3)\r");
cont+=3;
Sleep(300);
//controla as valuvas solenoide
if((numericUpDown2->Value) == 1)
{
serial->WriteLine("\rcim2.io2.set(1)\r");
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
cont+=3;
Sleep(300);
}
//Regula a temperatura
if((numericUpDown1->Value)
>
20
&&
>=
24
&&
>=
27
&&
(numericUpDown1->Value) <= 23)
{
serial>WriteLine("\rcim1.pwm0.on(4)\r");
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
>=
31
&&
>=
34
&&
>=
37
&&
>=
41
&&
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
>=
44
&&
{
cont+=3;
Sleep(300);
}
if((numericUpDown1->Value) >= 47)
{
cont+=3;
Sleep(300);
}
MessageBox::Show("");
//termina a funcao de leitura de lixo
for(int i=0; i<cont; i++)
{
System::String^
lixo
=
serial-
>ReadLine();
//
Sleep(200);
}
MessageBox::Show("O
Chuveiro
Inteligente
está ligado.");
}
else
{
MessageBox::Show("Porta com problema.");
}
}
private: System::Void button2_Click(System::Object^
sender, System::EventArgs^
e) {
if(serial->IsOpen == true)
{
//Varivel conta
int cont;
Sleep(300);
cont+=3;
Sleep(300);
cont+=3;
Sleep(300);
cont+=3;
Sleep(300);
{
System::String^
lixo
=
serial-
>ReadLine();
}
serial->Close();
}
else
{
MessageBox::Show("Porta já está fechada.");
}
}
e) {
{
//Le o sensor de temperatura
serial->Write("\rcim2.io1.getadc()\r");
Sleep(100);
System::String^ lixo= serial->ReadLine();
Sleep(100);
System::String^ sensor = serial->ReadLine();
int valor = System::Int32::Parse(sensor);
int valorSensor = valor / 2.048;
(numericUpDown3->Value) = valorSensor;
}
else
{
MessageBox::Show("O chuveiro está desligado.");
}
}
e) {
{
//Le e atualiza a temperatura do banho
serial->Write("cim2.io1.getadc()\r");
Sleep(200);
System::String^ lixo= serial->ReadLine();
Sleep(200);
System::String^ sensor2 = serial->ReadLine();
int valor2 = System::Int32::Parse(sensor2);
int valorSensor2= valor2 / 2.048;
(numericUpDown3->Value) = valorSensor2;
int cont;
//controla as valuvas selenoide
{
cont+=3;
Sleep(300);
cont+=3;
Sleep(300);
}
if((numericUpDown2->Value) ==2)
{
cont+=3;
Sleep(300);
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
cont+=3;
Sleep(300);
}
//Regula a temperatura
if((numericUpDown1->Value) <= 20)
{
cont+=3;
Sleep(300);
}
{
cont+=3;
>=
20
&&
Sleep(300);
}
>=
24
&&
>=
27
&&
>=
31
&&
>=
34
&&
>=
37
&&
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
>=
41
&&
>=
44
&&
{
cont+=3;
Sleep(300);
}
{
cont+=3;
Sleep(300);
}
if((numericUpDown1->Value) >= 47)
{
cont+=3;
Sleep(300);
}
//
MessageBox::Show("");
{
System::String^
>ReadLine();
//
Sleep(200);
lixo
=
serial-
}
MessageBox::Show("O Chuveiro Inteligente foi
atualizado.");
}
else
{
MessageBox::Show("O chuveiro está desligado.");
}
}
};
}
AssemblyInfo.cpp
#include "stdafx.h"
using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
using namespace System::Runtime::InteropServices;
using namespace System::Security::Permissions;
//
// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
//
[assembly:AssemblyTitleAttribute("ChuveiroInteligente")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("Grosko")];
[assembly:AssemblyProductAttribute("ChuveiroInteligente")];
[assembly:AssemblyCopyrightAttribute("Copyright (c) Grosko 2009")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
//
// Version information for an assembly consists of the following four values:
//
//
Major Version
//
Minor Version
//
Build Number
//
Revision
//
// You can specify all the value or you can default the Revision and Build Numbers
// by using the '*' as shown below:
[assembly:AssemblyVersionAttribute("1.0.*")];
[assembly:ComVisible(false)];
[assembly:CLSCompliantAttribute(true)];
[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode =
true)];
ChuveiroInteligente.cpp
// ChuveiroInteligente.cpp : main project file.
#include "stdafx.h"
#include "Form1.h"
using namespace ChuveiroInteligente;
[STAThreadAttribute]
int main(array<System::String ^> ^args)
{
// Enabling Windows XP visual effects before any controls are created
Application::EnableVisualStyles();
Application::SetCompatibleTextRenderingDefault(false);
// Create the main window and run it
Application::Run(gcnew Form1());
return 0;
}
5.2 – POSTAGENS NO WEBSITE
SEGUNDA-FEIRA, 22 DE JUNHO DE 2009
22- 06 "Quanto mais amarga a batalha, mais doce é a vitória!"
Documentação está na etapa final, todo o grupo discute constantemente sobre as possíveis
melhorias que poderiam ter ocorrido, possíveis vantagens do projeto que não foram suficiente
exploradas. É um momento de amadurecimento muito propício para todos, afinal, olhar para trás e
ver o quanto crescemos! Ver que somos capazes de retribuir a sociedade tudo que ela nos deu com
nosso trabalho! Usufluindo de nosso esforço e um pouco de talento.
POSTADO POR CHUVEIRO INTELIGENTE ÀS 16:02 0 COMENTÁRIOS
DOMINGO, 14 DE JUNHO DE 2009
12/06 "Missão dada é missão comprida"
Nesse final de semana prolongado, por causa do feriado, todos juntaram todas as esperanças e
forças em terminar a estrutura! Ficou faltando 2 toquinho de madeira para prender o servo motor(que
irá controlar a temperatura) e aquela clássica limpada para causar boa impressão na apresentação.
A documentação caminhou a largos passos, faltando somente algumas normas da ABNT para
revisar e a releitura de todos os integrantes do grupo.
DOMINGO, 7 DE JUNHO DE 2009
03 - 06 "Nada dignifica mais o homem que o trabalho! Principalmente
depois de feito."
Com o programa finalmente pronto, com todas as funções funcionando, começamos a concentrar
forças nos acabamentos finais(caixa para os circuitos, ajustes finos e testes) e documentação.
QUARTA-FEIRA, 27 DE M AIO DE 2009
23 - 05 "Seria a função do engenheiro vencer o equilíbrio?"
Descobriu-se o problema! Que fazia o circuito parar de funcionar sem motivos aparente, um curto
acontecia no cabo conector e as placas. Foi refeita a ponteira do cabo, e com isso esperamos
resolver definitivamente esse problema. Novamente testado o programa, o circuito continua sem
responder. A base que será usada e os encanamentos estão quase prontros.
22 - 05 "O equílibrio continua, conserta-se uma coisa e a outra quebra
sozinha!"
Com os novos PIC, foram novamente programados.O programa continua sem localizar a porta COM
corretamente, é como se o circuito não reconhece o computador e vice-versa!
DOMINGO, 24 DE MAIO DE 2009
20 - 05 "Nada que é bom vem de graça! "
Conseguimos finalmente fazer o conversor serial funcionar,indentificamos o problema como "mau
instalação do driver" e a falta de um outro cabo que "desenvertia" o sinal serial. Testamos o
programa porém continua sem solução, e os pic ficaram com inveja, pois só o cabo serial estava
recebendo atenção e resolveram não funcionar mais!
14-05 "Quando vejo a faixa de chegada, percebo que mais um esforço
ainda é necessário!"
Foram testadas todas as placas com o programa, o qual irá controlar todo o sistema, porém,
não foi obtido sucesso, afinal, o programa está com um erro, para detectar a porta de
conecção USB, pois o notebook usado para programar não possui o conector serial usado
como método de comunicação "circuito-computador"(Porém quando testado nos
computadores fornecidos pela PUC que possuem tal conector funcionou como esperado), e
na parte de leitura dos sensores de temperatura(Que aparentemente demonstra ser mais
um erro da própia peça do que do software).
08 - 05 "Começando a ver a curva da chegada"
Começamos a estrutura pra o chuveiro, o bruto pelos já, e também demos início a idealização de como posicionar as
válvulas, chuveiro e circuitos. O programa recebeu diversas modificações com o intuito de ter maior controle sobre toda
a estrutura
SÁB ADO, 2 DE MAIO DE 2009
28/04 "Curto e grosso"
Foi finalizada a placa da etapa de potência da válvula selonóide de 127V, e ja compramos o material
para a estrutura de apresentação do chuveiro.
SEXTA-FEIR A, 24 DE ABRIL DE 2009
20/04 - "Pensando como um chuveiro..."
Iniciou-se a programação do chuveiro, em C++, com interface amigável. Estamos enfrentando
problemas com o sensor de temperatura do chuveiro, as equações prontas não satisfazem o
problema, nos forçando a contruir uma amostragem de dados para construir a equação a partir de
um gráfico.
14 - 04 "Nada como um dia após o outro"
Adaptamos os sensores de temperatura, conseguimos testar as placas dos circuitos, com exito. A
placa do módulo M2 teve o pic queimado por motivos ainda não conhecidos e um dos sensores
adaptados não está funcionando corretamente por motivos de imperícia para manipular sua
adaptação.
QUINTA-FEIRA, 9 DE ABRIL DE 2009
06 - 04 "O deus da persistência nos agraciou por nossa intensa
devoção!"
Finalmente o esforço foi recompensado! Desta vez obtivemos sucesso com a corrosão das
placas e a solda de todos os componentes na mesma. Porém, infelizmente, não houve
tempo suciente para todos os testes necessários do material produzido, pois a confecção
das placas foi finalizada quase que no final do dia!
03 - 04 "Só no dicionário que a palavra sucesso vem antes que
trabalho - Einstein"
Tentamos novamente produzir as plaquinhas, mas novamente não conseguimos realizar os
objetivos, dessa vez porque fizemosu m espelhamento da imagem que não era necessário, fazendo
o circuito ficar invertido. Desta vez não houve aproveitamento decorativo e foi tudo para o lixo!
02 - 04 "Pondo os buracos nos eixos"
Nessa quinta tentamos corroer algumas placas para ja deixar finalizado algumas etapas,
porem não fomos felizes nessa empreitada, pois ao converter a imagem do circuito EAGLE
em pdf, perdemos algumas precisões, principalmente nas 8 perninhas do CI. Não havendo
mais como remediar a situação, acabou-se por deixar como decorativo esse resultado!
Conseguimos realizar as adaptações de isolamento no sensor de temperatura e ja foi
comprado o chuveiro para podermos realizar as necessárias adaptações.
26-03 "Aterrando idéias"
Conseguimos finalmente testar a válvula selonóide, estava sem defeito, porém, sem responder às
instruções do hyperterminal. Enquanto testávamos a válvula o módulo M2 deu alguns problemas, e
após revisar todo o circuito, ficou claro que só não estava aterrado!E, a partir disso, a válvula
solenóide passou a funcionar. Houve a solda da porta de comunicação serial.
25/03 "Indiana Comp em Busca do Motor de Passo Perdido"
Conseguimos dar início montagem do módulo M1, infelizmente não conseguimos testar o
motor de passo, que foi encomendado para ser usado na etapa de potência que alimentará
à válvula solenóide. Conseguimos incrementar ao módulo M2 alguns sensores de
temperatura que já foram testados com sucesso!
QUARTA-FEIRA, 25 DE M ARÇO DE 2009
20/04 "renaming"
Descoberto que o problema do módulo M2 era o *.rename(), começou uma seção de testes, e fomos
muito felizes com a situação, obtendo os resultados almejados. O integrante Tiago conseguiu uma
válvula solenóide, que foi testada, aparte do módulo M2 pois ela consumia muita energia,
necessitando acrescentar uma etapa de potência ao módulo M2.
19/04 "Por falta de 1, agora temos 2"
Nesse dia, com cabos em mãos, começamos a testar o módulo RS232-TTL porém não houve muito
exito, pois não estava aterrado, capacitor com funcionamento improdutivo. O módulo M2 continua
sem funcionar por motivo desconhecido.
"Engatinhando" 18/03
Nas primeiras semanas, após definirmos como certo que o tema do projeto seria o Chuveiro
Inteligente, demos "início as coisas primeiras"e iniciamos a construção e experimentação do módulo
RS 232-TTL que servirá como porta de comunicação do computador e o Chuveiro Inteligente. Demos
início a montagem em protoboard do módulo M2, mas nenhum dos equipamentos montados
puderam ser testados por falta de cabo serial e válvula solenóide.
Descrição Inicial
Chuveiro Inteligente
Esse blog foi criado com o intuito de divulgar as características, problemas, soluções e novidades
mais recentes do projeto integrado ministrado pelo professor Afonso Ferrei Miguel, professor de
Resoluções de Problemas de Engenharia. Como parte integrante de avaliação e de desenvolvimento
de conceitos e métododos que serão continuamente usados para o aprimoramento do nosso primeiro
grande problema acadêmico, o Chuveiro Inteligente.
O projeto será desenvolvidopor :

Carlos Roberto Remenche Junior.

Denis Reimche Ott

Rafael Antonio Grosko
6 – CONCLUSÃO
Esse foi um projeto muito fértil. Digo fértil porque toda a dedicação que foi investida
no trabalho, trouxe frutos de valorosos aprendizados de hidráulica, eletrônica, programação,
maquetaria e organização para desenvolver grandes projetos. A oportunidade de
desenvolver essa idéia, embora precisássemos de mais tempo para conseguir aprimorar
todos os conceitos que a envolvem de maneira mais aprofundada e otimizada, foi
gratificante e proporcionou um amadurecimento dos integrantes do grupo além do
esperado.
Algumas características do nosso projeto poderiam ser melhor implementadas, se
houvesse mais tempo para tal. Um bom exemplo seria o maior quantidade de níveis de
vazão, programamos somente 3 níveis, seria algo como “pouco”, “médio” e “bastante”. Seria
mais interessante ter 10 níveis, traria maior conforto a escolhas de vazão. Outro ponto que
poderia ser otimizado seria um controle e um método para aquecer a água até a
temperatura desejada mais rápida, desperdiçaria menos água enquanto espera-se a
transição da escolha.
Todo o grupo espera que se alguém resolva dar continuidade ao nosso projeto,
que comece focando formas mais inteligentes de disposição das peças, a fim de
economizar espaço. Pesquise e manuseie um catálogo de peças hidráulicas, para adquirir
valorizada familiaridade com o mesmo. Isso poupa tempo, ajuda a enxergar soluções mais
eficazes de encanamento e a economizar não comprando sobressalentes.
Ressalto sobre a importância das peças hidráulicas, pois foi a dificuldade principal
do grupo, como todos eram da mesma área, ninguém tinha a familiaridade necessária com
a área, e isso trouxe dificuldades imediatas como um todo.
É um projeto extremamente interessante, de uso cotidiano, que traria perceptíveis
melhorias para as pessoas de um modo geral. Foi uma experiência enobrecedora ver o
quanto de trabalho está por fazer para melhorar as condições da nossa sociedade, e esse
foi só um deles.

pontifícia universidade católica do paraná centro de

Transcrição

Documentos relacionados

(PROPOSTA VE15-096 - Remodela\347\343o casa banho

Como evitar o desperdício de água

zoning system

Duro de Errar 4.0 Tratamento de Erros em PHP

A - Funções do programa VLC

Relatórios na WEB

sanitários

Chuveiro e Lava-olhos Haws 8320G BR

68 horas NÚMERO DE CRÉDITOS: 4 EMENTA: Conceito

Dicas Home System.cdr

documentação - microprocessadores.com.br

Relatório Final