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 Marcos Jess e Afonso Ferreira Miguel.

CURITIBA

2009

Í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 com base nas leituras de

temperaturas previamente escolhidas pelo usuário.

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::NumericUpDown^ numericUpDown2;

private: System::Windows::Forms::Label^ label1;

private: System::Windows::Forms::Label^ label2;

private: System::IO::Ports::SerialPort^ serial;

private: System::Windows::Forms::Timer^ timer1;

private: System::Windows::Forms::Label^ label3;

private: System::Windows::Forms::Button^ button2;

private: System::Windows::Forms::Button^ button3;

private: System::Windows::Forms::Button^ button4;

private: System::Windows::Forms::NumericUpDown^ numericUpDown3;

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

System::Windows::Forms::NumericUpDown());

this->numericUpDown2 = (gcnew

System::Windows::Forms::NumericUpDown());

this->label1 = (gcnew System::Windows::Forms::Label());

this->label2 = (gcnew System::Windows::Forms::Label());

this->serial = (gcnew System::IO::Ports::SerialPort(this-

>components));

this->timer1 = (gcnew System::Windows::Forms::Timer(this-

>components));

this->label3 = (gcnew System::Windows::Forms::Label());

this->button2 = (gcnew System::Windows::Forms::Button());

this->button3 = (gcnew System::Windows::Forms::Button());

this->button4 = (gcnew System::Windows::Forms::Button());

this->numericUpDown3 = (gcnew

System::Windows::Forms::NumericUpDown());

(cli::safe_cast<System::ComponentModel::ISupportInitialize^

>(this->numericUpDown1))->BeginInit();

(cli::safe_cast<System::ComponentModel::ISupportInitialize^

>(this->numericUpDown2))->BeginInit();

(cli::safe_cast<System::ComponentModel::ISupportInitialize^

>(this->numericUpDown3))->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

cli::array< System::Int32 >(4) {20, 0, 0, 0});

this->numericUpDown1->Name = L"numericUpDown1";

this->numericUpDown1->Value = System::Decimal(gcnew

cli::array< System::Int32 >(4) {20, 0, 0, 0});

//

// numericUpDown2

//

resources->ApplyResources(this->numericUpDown2,

L"numericUpDown2");

this->numericUpDown2->Maximum = System::Decimal(gcnew

cli::array< System::Int32 >(4) {3, 0, 0, 0});

this->numericUpDown2->Minimum = System::Decimal(gcnew

cli::array< System::Int32 >(4) {1, 0, 0, 0});

this->numericUpDown2->Name = L"numericUpDown2";

this->numericUpDown2->Value = System::Decimal(gcnew

cli::array< System::Int32 >(4) {1, 0, 0, 0});

//

// label1

//

resources->ApplyResources(this->label1, L"label1");

this->label1->ForeColor =

System::Drawing::SystemColors::HotTrack;

this->label1->Name = L"label1";

//

// label2

//

resources->ApplyResources(this->label2, L"label2");

this->label2->ForeColor =

System::Drawing::SystemColors::HotTrack;

this->label2->Name = L"label2";

//

// serial

//

this->serial->BaudRate = 1200;

this->serial->PortName = L"COM5";

//

// timer1

//

this->timer1->Enabled = true;

this->timer1->Interval = 600000;

//

// label3

//

resources->ApplyResources(this->label3, L"label3");

this->label3->Name = L"label3";

//

// button2

//

resources->ApplyResources(this->button2, L"button2");

this->button2->Name = L"button2";

this->button2->UseVisualStyleBackColor = true;

this->button2->Click += gcnew System::EventHandler(this,

&Form1::button2_Click);

//

// button3

//

resources->ApplyResources(this->button3, L"button3");

this->button3->Name = L"button3";

this->button3->UseVisualStyleBackColor = true;

this->button3->Click += gcnew System::EventHandler(this,

&Form1::button3_Click);

//

// button4

//

resources->ApplyResources(this->button4, L"button4");

this->button4->Name = L"button4";

this->button4->UseVisualStyleBackColor = true;

this->button4->Click += gcnew System::EventHandler(this,

&Form1::button4_Click);

//

// numericUpDown3

//

resources->ApplyResources(this->numericUpDown3,

L"numericUpDown3");

this->numericUpDown3->Increment = System::Decimal(gcnew

cli::array< System::Int32 >(4) {0, 0, 0, 0});

this->numericUpDown3->Name = L"numericUpDown3";

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

this->Controls->Add(this->button2);

this->Controls->Add(this->label3);

this->Controls->Add(this->label2);

this->Controls->Add(this->label1);

this->Controls->Add(this->numericUpDown2);

this->Controls->Add(this->numericUpDown1);

this->Controls->Add(this->button1);

this->ForeColor = System::Drawing::SystemColors::HotTrack;

this->Name = L"Form1";

this->Opacity = 0.94;

(cli::safe_cast<System::ComponentModel::ISupportInitialize^

>(this->numericUpDown1))->EndInit();

(cli::safe_cast<System::ComponentModel::ISupportInitialize^

>(this->numericUpDown2))->EndInit();

(cli::safe_cast<System::ComponentModel::ISupportInitialize^

>(this->numericUpDown3))->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);

}

if((numericUpDown2->Value) == 2)

{

serial->WriteLine("\rcim2.io4.set(1)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown2->Value) == 3)

{

serial->WriteLine("\rcim2.io2.set(1)\r");

cont+=3;

Sleep(300);

serial->WriteLine("\rcim2.io4.set(1)\r");

cont+=3;

Sleep(300);

}

//Regula a temperatura

if((numericUpDown1->Value) > 20 &&

(numericUpDown1->Value) <= 23)

{

serial-

>WriteLine("\rcim1.pwm0.on(4)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 24 &&

(numericUpDown1->Value) <= 26)

{

serial-

>WriteLine("\rcim1.pwm0.on(5)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 27 &&

(numericUpDown1->Value) <= 30)

{

serial-

>WriteLine("\rcim1.pwm0.on(6)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 31 &&

(numericUpDown1->Value) <= 33)

{

serial-

>WriteLine("\rcim1.pwm0.on(7)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 34 &&

(numericUpDown1->Value) <= 36)

{

serial-

>WriteLine("\rcim1.pwm0.on(8)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 37 &&

(numericUpDown1->Value) <= 40)

{

serial-

>WriteLine("\rcim1.pwm0.on(9)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 41 &&

(numericUpDown1->Value) <= 43)

{

serial-

>WriteLine("\rcim1.pwm0.on(10)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 44 &&

(numericUpDown1->Value) <= 46)

{

serial-

>WriteLine("\rcim1.pwm0.on(11)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 47)

{

serial-

>WriteLine("\rcim1.pwm0.on(12)\r");

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

serial->WriteLine("\rcim2.io2.set(0)\r");

cont+=3;

Sleep(300);

serial->WriteLine("\rcim2.io4.set(0)\r");

cont+=3;

Sleep(300);

serial->WriteLine("\rcim1.pwm0.on(3)\r");

cont+=3;

Sleep(300);

//termina a funcao de leitura de lixo

for(int i=0; i<cont; i++)

{

System::String^ lixo = serial-

>ReadLine();

}

serial->Close();

}

else

{

MessageBox::Show("Porta já está fechada.");

}

}

private: System::Void button3_Click(System::Object^ sender, System::EventArgs^

e) {

if(serial->IsOpen == true)

{

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

}

}

private: System::Void button4_Click(System::Object^ sender, System::EventArgs^

e) {

if(serial->IsOpen == true)

{

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

if((numericUpDown2->Value) == 1)

{

serial->WriteLine("\rcim2.io2.set(1)\r");

cont+=3;

Sleep(300);

serial->WriteLine("\rcim2.io4.set(0)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown2->Value) ==2)

{

serial->WriteLine("\rcim2.io4.set(1)\r");

cont+=3;

Sleep(300);

serial->WriteLine("\rcim2.io2.set(0)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown2->Value) == 3)

{

serial->WriteLine("\rcim2.io2.set(1)\r");

cont+=3;

Sleep(300);

serial->WriteLine("\rcim2.io4.set(1)\r");

cont+=3;

Sleep(300);

}

//Regula a temperatura

if((numericUpDown1->Value) <= 20)

{

serial->WriteLine("\rcim1.pwm0.on(3)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 20 &&

(numericUpDown1->Value) <= 23)

{

serial-

>WriteLine("\rcim1.pwm0.on(4)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 24 &&

(numericUpDown1->Value) <= 26)

{

serial-

>WriteLine("\rcim1.pwm0.on(5)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 27 &&

(numericUpDown1->Value) <= 30)

{

serial-

>WriteLine("\rcim1.pwm0.on(6)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 31 &&

(numericUpDown1->Value) <= 33)

{

serial-

>WriteLine("\rcim1.pwm0.on(7)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 34 &&

(numericUpDown1->Value) <= 36)

{

serial-

>WriteLine("\rcim1.pwm0.on(8)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 37 &&

(numericUpDown1->Value) <= 40)

{

serial-

>WriteLine("\rcim1.pwm0.on(9)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 41 &&

(numericUpDown1->Value) <= 43)

{

serial-

>WriteLine("\rcim1.pwm0.on(10)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 44 &&

(numericUpDown1->Value) <= 46)

{

serial-

>WriteLine("\rcim1.pwm0.on(11)\r");

cont+=3;

Sleep(300);

}

if((numericUpDown1->Value) >= 47)

{

serial-

>WriteLine("\rcim1.pwm0.on(12)\r");

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

S E G U N D A - F E I R A , 2 2 D E J U N H O D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 6 : 0 2 0 C O ME N TÁ R I OS

D O M I N G O , 1 4 D E J U N H O D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 0 7 : 1 6 0 C O ME N TÁ R I OS

D O M I N G O , 7 D E J U N H O D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 7 : 4 3 0 C O ME N TÁ R I OS

Q U A R T A - F E I R A , 2 7 D E M A I O D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 0 8 : 3 4 0 C O ME N TÁ R I OS

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!

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 0 8 : 2 2 0 C O ME N TÁ R I OS

D O M I N G O , 2 4 D E M A I O D E 2 0 0 9

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!

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 6 : 5 7 0 C O ME N TÁ R I OS

D O M I N G O , 1 7 D E M A I O D E 2 0 0 9

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

D O M I N G O , 1 0 D E M A I O D E 2 0 0 9

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

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 6 : 5 0 0 C O ME N TÁ R I OS

S Á B A D O , 2 D E M A I O D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 5 : 0 3 0 C O ME N TÁ R I OS

S E X T A - F E I R A , 2 4 D E A B R I L D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 6 : 5 4 0 C O ME N TÁ R I OS

S E X T A - F E I R A , 1 7 D E A B R I L D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 7 : 0 7 0 C O ME N TÁ R I O S

Q U I N T A - F E I R A , 9 D E A B R I L D E 2 0 0 9

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!

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 9 : 3 1 0 C O ME N TÁ R I OS

S E X T A - F E I R A , 3 D E A B R I L D E 2 0 0 9

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!

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 2 0 : 1 1 0 C O ME N TÁ R I OS

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 6 : 2 4 0 C O ME N TÁ R I OS

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!

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 5 : 5 8 0 C O ME N TÁ R I OS

Q U A R T A - F E I R A , 2 5 D E M A R Ç O D E 2 0 0 9

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 0 : 4 3 0 C O ME N TÁ R I OS

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.

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 0 : 3 8 0 C O ME N TÁ R I OS

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

P O S TA D O P O R C H UV EI R O I N TE L I GE N T E À S 1 0 : 1 6 0 C O ME N TÁ R I OS

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.