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

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.

foram colocados os componentes soldando-os nas placas. foram feitas diversas modificações para torná-lo mais forte. Nas primeiras semanas foi comprado o material para a montagem do circuito elétrico. foram enfrentados muitos problemas. Após a conclusão dessas etapas ainda restava o programa. os problemas foram resolvidos e o programa ficou pronto. Com os desenhos das placas prontos começou a fabricação das placas de circuito impresso.1. que é o C++ em Windows Form usando o Visual Studio. só restava à montagem da estrutura. .METODOLOGIA O método usado para desenvolver o “Chuveiro Inteligente” consistiu em uma pesquisa sobre os módulos a serem implementados no circuito. a programação foi o foco central do trabalho. foi montada a estrutura e realizados alguns testes para verificar o funcionamento de tudo produzido até o momento.chuveirointeligente. tanto pelo estudo da linguagem. para serem impressos nas placas de maneira mais segura e profissional. em primeiro momento em proto-board. assim como também foi iniciado os estudos da linguagem a ser utilizada para a programação. No programa. Com os circuitos prontos. usando o programa Eagle. curiosidades e tudo que o envolve. Com todos os ajustes feitos. testamos o funcionamento de todo o circuito junto com todos os componentes adicionais (sensores.com.blogspot.2 . para aprender e verificar o funcionamento e verificar a montagem adequada do circuito para evitar erros como curto circuitos. servo motores). O site do projeto é www. Tivemos que substituir uma válvula solenóide por uma bomba de combustível de carro. com todo o circuito montado em proto-board. Nas seguintes semanas. para aumentar a vazão para suprir a quantidade de água que o chuveiro necessita. descobrimos que o peso do chuveiro com a água seria pesado demais para a estrutura. Com os circuitos prontos e testados para evitar curtos entre as trilhas. colocando as válvulas solenóide. que já estava em fase final. como seria a melhor maneira de controlar a água e temperatura. faltando alguns ajustes e testes. diagramas. Com a aquisição dos materiais necessários. que logo foi concluída com a aquisição dos materiais necessários e montagem. quanto pelo código utilizado. foi dado inicio ao desenho dos circuitos. fotos. que foi iniciada na semana seguinte. válvulas solenóides. um Web Site foi colocado no ar com informações do projeto e no decorrer do mesmo foi atualizado semanalmente com histórias. Com ela pronta foi projetada a parte hidráulica. Com as placas corroídas e com as trilhas perfeitas.

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. 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. com estrutura laboratorial e funcionários dedicados foram parte fundamental para o desenvolvimento e amadurecimento contínuo do mesmo. assim como dos professores. A PUC. .

3 – OBJETIVOS O projeto “Chuveiro Inteligente” teve como objetivo. fosse capaz de automaticamente regular temperatura com base nas leituras de temperaturas previamente escolhidas pelo usuário. se o usuário consegui-se atingir a temperatura de banho que ele julga-se adequada mais rápido. tudo que envolve um adequado gerenciamento de projeto. como a utilização dos conceitos de circuitos elétricos e sistemas digitais para uma interpretação real das tecnologias empregadas no projeto. Sem relevar a oportunidade de poder desenvolver algo que aumente o conforto do usuário durante o banho. apresentações. Haveria economia de água e energia. dispensado aquele clássico ritual de “calibração” da temperatura e quantidade todas vez antes do banho. Como circuitos elétricos e sistemas digitais que foram exaustivamente revisadas e aplicadas durante o mesmo. documentações. cronogramas. que em alguns casos é relativamente demorada. . o aprendizado sobre pesquisas. ou seja. ou seja. assim como utilizar conhecimentos recebidos em sala de aula já em aplicações mais próximas da engenharia propriamente dita.

como um contador de quantidade de água vazante.3.1 – NÃO ESTÁ INCLUSO NO ESCOPO DO PROJETO Poderiam ser incluídas diversas funcionalidades no nosso projeto. um monitor touch-screen de pequena escala para ser usado como interface usuário-máquina. de energia utilizada. entre vários outros. pois dependeria de muito mais tempo. pois um semestre foi insuficiente nos condenando a uma superficialidade do todo que poderia ser. . Não foram implementados neste projeto. estudo de novas possibilidades e custos por parte do grupo. é sem dúvida um projeto muito fértil para quem quer proporcionar conforto e controle total durante o banho.

Rafael Antônio Grosko.EQUIPE DE DESENVOLVIMENTO A equipe de desenvolvimento contou com Carlos Roberto Remenche Junior. Denis Reimche Ott.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 .4 .

PROGRAMAÇÃO. sensor e motor. para dar suporte ao chuveiro. Todos módulos foram construídos através dos esquemáticos disponibilizados pelo professor Afonso. válvulas de controle. Foi utilizado primariamente. transporte e apresentação do sistema. Toda a parte hidráulica. Para o controle das válvulas. para realizar a comunicação computador<->módulos. 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. caixa com as placas de circuito foi anexada à essa estrutura. O sistema recebe a alimentação de água por meio de uma torneira normal com vazão suficiente para ligar o . retirada da placa inicial. em posição vertical.O PROJETO O projeto foi constituído de três fases: HARDWARE. foi utilizada uma tubulação padrão de PVC em conjunto com mangueiras de silicone para melhor visualização do movimento da água. As placas e a fonte foram acomodados em uma caixa de plástico própria para circuitos para melhor organização. ESTRUTURA HIDRÁULICA. Outra placa de madeira.5 . foi presa à base. sensor e motor servo foram utilizados módulos específicos (M2 e M1). A estrutura hidráulica consiste em uma placa de madeira(MDF) em formato de U que serve como base principal para o projeto. A parte do Hardware foram utilizadas para implementar a comunicação e controle via software entre o computador e as válvulas. o conversor RS 232-TTL que utiliza uma entrada serial pra comunicação com o computador. Como ilustra a foto.

de plástico e suporte em metal. podendo assim ser fixado em qualquer posição próxima ao chuveiro. ideal para controlar um pequeno dispositivo como o . com um dispositivo que ao ser girado modifica sua resistência deixando passar mais ou menos corrente. ao ser girado modifica a potência que o chuveiro tem para aquecer a água.de material metálico. necessitando assim de uma alimentação direta da rede elétrica. Pela tubulação ser de PVC e a válvula ser metálica houve certa dificuldade em adaptar ela ao conjunto. Este motor tem como característica o controle preciso de seus movimentos. Ela opera com 110V. Para controlar este dispositivo foi utilizado um motor servo.chuveiro. este foi ligado à um motor servo e ambos foram presos com madeira à base principal. 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. servindo esta como suporte. Por meio de uma mangueira essa água chega a parte hidráulica do projeto. este utiliza uma fiação para se ligar ao chuveiro. ou seja. Por ter essa facilidade de mobilidade do potenciômetro este chuveiro foi escolhido para o projeto. O potenciômetro consiste em uma pequena caixa. A primeira válvula . uma para cada válvula. foi retirada de uma máquina de lavar. A segunda válvula. As válvulas foram fixadas na tubulação. elas em seu interior contém um eletro-imã fixo. Utiliza 12V para operar. Essa última tubulação sobe pela placa vertical da base. em uma conexão em formato T a água é dívida em duas tubulações. esse eletro-imã entra em ação atraindo o pedaço de metal. podendo este ser integrado facilmente aos circuitos previamente discutidos. Duas válvulas solenóides (ou eletro-válvulas) foram utilizadas para o controle da vazão da água. de forma que as válvulas poderiam ser utilizadas em conjunto ou separadas. Se não existir a alimentação elétrica. Essas válvulas operam de modo simples. que utiliza um controle de temperatura manual por meio de um potenciômetro. ligado ao chuveiro por um cabo elétrico. Se a válvula é alimentada com a voltagem correta. O chuveiro utilizado foi um chuveiro eletrônico da marca Zagonel. O motor usado foi obtido do sistema de controle de polarização de uma antena parabólica. Para controlá-la foi utilizado um relé que é acionado com 12V. a válvula permanece fechada. puxando assim juntamente a parte plástica liberando assim passagem de água. foi retirada de um sistema de ar de um caminhão. 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. Para o controle de temperatura foi utilizado o potenciômetro original do chuveiro. mudando assim a temperatura da água que o chuveiro fornece. o pedaço de metal não é atraído e por meio de uma mola. depois de passar pelas válvulas a água chega a outra conexão em T que une as duas tubulações. um pedaço de metal é preso a uma parte móvel que corre por dentro de um pequeno vão dentro da válvula.

Este programa será melhor discutido em outro item. Este sensor é ligado ao circuito para leitura da temperatura da água no chuveiro. utilizando o programa Visual Studio. O software foi desenvolvido em plataforma Windows. . Foi utilizado ainda o Windows Form para facilitar o geração da parte gráfica do programa. O computador foi ligado ao sistema por um conversor USB-Serial pela comodidade que existe em usar a porta USB. Todo o controle é feito via software ligado ao sistema pelo módulo de conversão RS 232-TTL discutido previamente. ambos da empresa Microsoft. controlando assim o potenciômetro. Para verificar a temperatura. A linguagem de programação utilizada foi o C++.potenciômetro. foi utilizado um sensor acoplado ao chuveiro. Ele funciona com um controle vindo do módulo e gira de acordo com o comando fornecido.

h #include <windows. using namespace System::Collections. Otherwise. using namespace System::Windows::Forms.resx files this class depends on. 'Resource File Name' property for the managed resource compiler /// </summary> public ref class Form1 : public System::Windows::Forms::Form { public: Form1(void) { InitializeComponent().1 – CÓDIGO-FONTE form1. the designers will not be able to interact properly with localized resources associated with this form. /// <summary> /// Summary for Form1 /// /// WARNING: If you change the name of this class. using namespace System::Drawing.h> #pragma once namespace ChuveiroInteligente { using namespace System. using namespace System::ComponentModel. using namespace System::Data.5. // //TODO: Add the constructor code here // . you will need to change the /// tool /// /// /// associated with all .

private: private: System::ComponentModel::IContainer^ components.} protected: /// <summary> /// Clean up any resources being used. private: System::Windows::Forms::Label^ label1. } } private: System::Windows::Forms::Button^ button1. private: System::Windows::Forms::NumericUpDown^ numericUpDown3. private: System::Windows::Forms::Button^ button4. private: System::Windows::Forms::Label^ label2. private: System::IO::Ports::SerialPort^ serial. /// </summary> ~Form1() { if (components) { delete components. private: System::Windows::Forms::Button^ button3. private: System::Windows::Forms::Timer^ timer1. private: /// <summary> /// Required designer variable. private: System::Windows::Forms::Label^ label3. private: System::Windows::Forms::Button^ button2. /// </summary> . private: System::Windows::Forms::NumericUpDown^ numericUpDown2. protected: private: System::Windows::Forms::NumericUpDown^ numericUpDown1.

this->numericUpDown1 System::Windows::Forms::NumericUpDown()). this->button2 = (gcnew System::Windows::Forms::Button()). this->button1 = (gcnew System::Windows::Forms::Button()). this->button4 = (gcnew System::Windows::Forms::Button()). (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->numericUpDown1))->BeginInit(). /// </summary> void InitializeComponent(void) { this->components System::ComponentModel::Container()). = (gcnew = (gcnew System::IO::Ports::SerialPort(this= (gcnew = (gcnew . System::ComponentModel::ComponentResourceManager^ resources = (gcnew = (gcnew System::ComponentModel::ComponentResourceManager(Form1::typeid)). (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->numericUpDown2))->BeginInit(). this->numericUpDown2 System::Windows::Forms::NumericUpDown()). this->label3 = (gcnew System::Windows::Forms::Label()). (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->numericUpDown3))->BeginInit(). this->timer1 = (gcnew System::Windows::Forms::Timer(this>components)). this->numericUpDown3 System::Windows::Forms::NumericUpDown()). this->label2 = (gcnew System::Windows::Forms::Label()). this->label1 = (gcnew System::Windows::Forms::Label()). this->button3 = (gcnew System::Windows::Forms::Button()). this->serial >components)).do not modify /// the contents of this method with the code editor.#pragma region Windows Form Designer generated code /// <summary> /// Required method for Designer support .

this->numericUpDown2->Minimum = System::Decimal(gcnew cli::array< System::Int32 >(4) {1. 0. 0}). 0. = System::Decimal(gcnew = System::Decimal(gcnew += gcnew System::EventHandler(this. this->button1->Name = L"button1". this->numericUpDown1->Minimum = System::Decimal(gcnew cli::array< System::Int32 >(4) {20. this->numericUpDown1->Maximum = System::Decimal(gcnew cli::array< System::Int32 >(4) {50. 0}). // // button1 // resources->ApplyResources(this->button1. this->numericUpDown2->Maximum = System::Decimal(gcnew cli::array< System::Int32 >(4) {3. 0. this->numericUpDown1->Value cli::array< System::Int32 >(4) {20. L"label1"). // // numericUpDown1 // resources->ApplyResources(this->numericUpDown1. 0}). 0}). this->numericUpDown1->Name = L"numericUpDown1". L"numericUpDown2"). L"numericUpDown1"). 0. 0. 0. this->button1->UseVisualStyleBackColor = true. // // numericUpDown2 // resources->ApplyResources(this->numericUpDown2. this->button1->Click &Form1::button1_Click). 0. this->numericUpDown2->Name = L"numericUpDown2".this->SuspendLayout(). 0. L"button1"). 0}). 0}). 0. 0. . this->numericUpDown2->Value cli::array< System::Int32 >(4) {1. // // label1 // resources->ApplyResources(this->label1. 0. 0.

this->button2->UseVisualStyleBackColor = true.this->label1->ForeColor System::Drawing::SystemColors::HotTrack. this->label1->Name = L"label1". this->button2->Name = L"button2". // // label3 // resources->ApplyResources(this->label3. this->button2->Click &Form1::button2_Click). this->label2->ForeColor System::Drawing::SystemColors::HotTrack. // // timer1 // this->timer1->Enabled = true. this->label3->Name = L"label3". this->serial->PortName = L"COM5". this->timer1->Interval = 600000. . // // serial // this->serial->BaudRate = 1200. L"button3"). += gcnew = = System::EventHandler(this. L"button2"). // // button3 // resources->ApplyResources(this->button3. this->label2->Name = L"label2". // // label2 // resources->ApplyResources(this->label2. L"label2"). L"label3"). // // button2 // resources->ApplyResources(this->button2.

// // Form1 // resources->ApplyResources(this. this->Controls->Add(this->numericUpDown1). this->Controls->Add(this->numericUpDown2).this->button3->Name = L"button3". this->button4->Click &Form1::button4_Click). += gcnew System::EventHandler(this. 0. this->Controls->Add(this->numericUpDown3). this->Controls->Add(this->button1). // // button4 // resources->ApplyResources(this->button4. this->Controls->Add(this->label1). // // numericUpDown3 // resources->ApplyResources(this->numericUpDown3. = += gcnew System::EventHandler(this. L"button4"). this->numericUpDown3->Increment = System::Decimal(gcnew cli::array< System::Int32 >(4) {0. this->button3->UseVisualStyleBackColor = true. this->button3->Click &Form1::button3_Click). this->Controls->Add(this->button4). this->Controls->Add(this->label2). L"numericUpDown3"). this->numericUpDown3->TabStop = false. L"$this"). this->Controls->Add(this->button3). this->AutoScaleMode System::Windows::Forms::AutoScaleMode::Font. this->button4->UseVisualStyleBackColor = true. this->Controls->Add(this->label3). 0}). this->numericUpDown3->Name = L"numericUpDown3". . 0. this->button4->Name = L"button4". this->Controls->Add(this->button2).

cont+=3. //Liga o motor servo serial->WriteLine("\rcim1.pwm0. this->ResumeLayout(false). } #pragma endregion private: System::Void button1_Click(System::Object^ sender.on(3)\r").this->ForeColor = System::Drawing::SystemColors::HotTrack. System::EventArgs^ e) { if(serial->IsOpen == false){ serial->Open(). } . Sleep(300). serial->WriteLine("\rcim1. cont+=3.94. //funcao para leitura de lixo int cont. (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->numericUpDown2))->EndInit(). Sleep(300).pwm. this->Opacity = 0.io2. (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->numericUpDown1))->EndInit().set(1)\r"). cont+=3. Sleep(300). this->PerformLayout(). (cli::safe_cast<System::ComponentModel::ISupportInitialize^ >(this->numericUpDown3))->EndInit().T=96\r"). //controla as valuvas solenoide if((numericUpDown2->Value) == 1) { serial->WriteLine("\rcim2. this->Name = L"Form1".

Sleep(300). Sleep(300). } //Regula a temperatura if((numericUpDown1->Value) (numericUpDown1->Value) <= 23) { serial>WriteLine("\rcim1. serial->WriteLine("\rcim2.on(5)\r").io4.io4. cont+=3.io2. Sleep(300).pwm0. cont+=3. } if((numericUpDown1->Value) (numericUpDown1->Value) <= 26) { serial>WriteLine("\rcim1. Sleep(300). Sleep(300).pwm0.if((numericUpDown2->Value) == 2) { serial->WriteLine("\rcim2.on(4)\r"). } if((numericUpDown1->Value) (numericUpDown1->Value) <= 30) { >= 27 && >= 24 && > 20 && . } if((numericUpDown2->Value) == 3) { serial->WriteLine("\rcim2. cont+=3.set(1)\r").set(1)\r"). cont+=3.set(1)\r"). cont+=3.

pwm0. cont+=3. } if((numericUpDown1->Value) (numericUpDown1->Value) <= 40) { serial>WriteLine("\rcim1.on(9)\r"). Sleep(300). } if((numericUpDown1->Value) (numericUpDown1->Value) <= 43) { serial>WriteLine("\rcim1. Sleep(300). } if((numericUpDown1->Value) (numericUpDown1->Value) <= 36) { serial>WriteLine("\rcim1.on(8)\r"). Sleep(300). cont+=3.pwm0.on(7)\r"). cont+=3. } if((numericUpDown1->Value) (numericUpDown1->Value) <= 33) { serial>WriteLine("\rcim1. } >= 41 && >= 37 && >= 34 && >= 31 && .on(6)\r"). cont+=3.pwm0.on(10)\r"). cont+=3. Sleep(300).pwm0.serial>WriteLine("\rcim1. Sleep(300).pwm0.

on(12)\r"). lixo = serial- MessageBox::Show("O está ligado. Sleep(300).if((numericUpDown1->Value) (numericUpDown1->Value) <= 46) { serial>WriteLine("\rcim1.").on(11)\r"). Chuveiro Inteligente } else { MessageBox::Show("Porta com problema. Sleep(300). } } .pwm0. i++) { System::String^ >ReadLine().pwm0. // } Sleep(200). } MessageBox::Show(""). } >= 44 && if((numericUpDown1->Value) >= 47) { serial>WriteLine("\rcim1. cont+=3. i<cont."). cont+=3. //termina a funcao de leitura de lixo for(int i=0.

io2.").private: System::Void button2_Click(System::Object^ e) { if(serial->IsOpen == true) { //Varivel conta int cont. serial->WriteLine("\rcim1. serial->WriteLine("\rcim2. cont+=3. Sleep(300). System::EventArgs^ Sleep(300).pwm0. serial->WriteLine("\rcim2. Sleep(300). System::EventArgs^ . } } private: System::Void button3_Click(System::Object^ e) { if(serial->IsOpen == true) { sender.on(3)\r"). cont+=3. } else { MessageBox::Show("Porta já está fechada.io4. cont+=3. //termina a funcao de leitura de lixo for(int i=0. Sleep(300). sender. i++) { System::String^ >ReadLine(). i<cont.set(0)\r"). } lixo = serial- serial->Close().set(0)\r").

} else { MessageBox::Show("O chuveiro está desligado.getadc()\r"). int valorSensor = valor / 2.set(1)\r"). System::String^ sensor2 = serial->ReadLine().io2. int valor = System::Int32::Parse(sensor). cont+=3. System::String^ sensor = serial->ReadLine().048. Sleep(200)."). System::EventArgs^ int cont. System::String^ lixo= serial->ReadLine().048.getadc()\r").//Le o sensor de temperatura serial->Write("\rcim2. int valor2 = System::Int32::Parse(sensor2). .io1. //controla as valuvas selenoide if((numericUpDown2->Value) == 1) { serial->WriteLine("\rcim2.io1. Sleep(100). sender. (numericUpDown3->Value) = valorSensor2. (numericUpDown3->Value) = valorSensor. int valorSensor2= valor2 / 2. Sleep(100). Sleep(200). } } private: System::Void button4_Click(System::Object^ e) { if(serial->IsOpen == true) { //Le e atualiza a temperatura do banho serial->Write("cim2. System::String^ lixo= serial->ReadLine().

cont+=3. >= 20 && .set(1)\r"). Sleep(300). } if((numericUpDown2->Value) == 3) { serial->WriteLine("\rcim2. cont+=3.pwm0.set(1)\r").io4. } if((numericUpDown1->Value) (numericUpDown1->Value) <= 23) { serial>WriteLine("\rcim1. serial->WriteLine("\rcim2. cont+=3. cont+=3.on(4)\r").io2.io4. cont+=3.io4. } if((numericUpDown2->Value) ==2) { serial->WriteLine("\rcim2. Sleep(300). cont+=3.set(1)\r").set(0)\r"). } //Regula a temperatura if((numericUpDown1->Value) <= 20) { serial->WriteLine("\rcim1. Sleep(300).on(3)\r").pwm0. Sleep(300).Sleep(300).set(0)\r").io2. serial->WriteLine("\rcim2. Sleep(300). Sleep(300). cont+=3. serial->WriteLine("\rcim2.

Sleep(300).on(8)\r").pwm0.on(5)\r"). cont+=3.pwm0. cont+=3. Sleep(300). } if((numericUpDown1->Value) (numericUpDown1->Value) <= 33) { serial>WriteLine("\rcim1. } if((numericUpDown1->Value) (numericUpDown1->Value) <= 26) { serial>WriteLine("\rcim1. } if((numericUpDown1->Value) (numericUpDown1->Value) <= 30) { serial>WriteLine("\rcim1. cont+=3.pwm0.Sleep(300).on(6)\r"). cont+=3.on(7)\r"). Sleep(300). Sleep(300). } if((numericUpDown1->Value) (numericUpDown1->Value) <= 40) { >= 37 && >= 34 && >= 31 && >= 27 && >= 24 && . } if((numericUpDown1->Value) (numericUpDown1->Value) <= 36) { serial>WriteLine("\rcim1.pwm0.

pwm0. // Sleep(200).on(12)\r").pwm0. } >= 44 && >= 41 && // MessageBox::Show(""). Sleep(300). Sleep(300). cont+=3. } if((numericUpDown1->Value) >= 47) { serial>WriteLine("\rcim1.on(10)\r").pwm0. Sleep(300). cont+=3. cont+=3.serial>WriteLine("\rcim1. cont+=3. } if((numericUpDown1->Value) (numericUpDown1->Value) <= 43) { serial>WriteLine("\rcim1. i<cont.pwm0.on(11)\r"). lixo = serial- .on(9)\r"). i++) { System::String^ >ReadLine(). //termina a funcao de leitura de lixo for(int i=0. Sleep(300). } if((numericUpDown1->Value) (numericUpDown1->Value) <= 46) { serial>WriteLine("\rcim1.

using namespace System::Reflection. using namespace System::Runtime::CompilerServices. using namespace System::Security::Permissions. [assembly:AssemblyConfigurationAttribute("")]. [assembly:AssemblyProductAttribute("ChuveiroInteligente")]. . [assembly:AssemblyTrademarkAttribute("")].h" using namespace System.} MessageBox::Show("O Chuveiro Inteligente foi atualizado. Change these attribute values to modify the information // associated with an assembly. [assembly:AssemblyDescriptionAttribute("")]. // [assembly:AssemblyTitleAttribute("ChuveiroInteligente")].").").cpp #include "stdafx. [assembly:AssemblyCopyrightAttribute("Copyright (c) Grosko 2009")]. using namespace System::Runtime::InteropServices. // // General Information about an assembly is controlled through the following // set of attributes. } else { MessageBox::Show("O chuveiro está desligado. } AssemblyInfo. [assembly:AssemblyCultureAttribute("")]. } } }. [assembly:AssemblyCompanyAttribute("Grosko")].

UnmanagedCode = true)].0.h" #include "Form1. [assembly:ComVisible(false)]. .*")].h" using namespace ChuveiroInteligente.cpp // ChuveiroInteligente. [assembly:CLSCompliantAttribute(true)]. [assembly:SecurityPermission(SecurityAction::RequestMinimum.cpp : main project file. #include "stdafx. ChuveiroInteligente. [STAThreadAttribute] int main(array<System::String ^> ^args) { // Enabling Windows XP visual effects before any controls are created Application::EnableVisualStyles().// // Version information for an assembly consists of the following four values: // // // // // // // You can specify all the value or you can default the Revision and Build Numbers // by using the '*' as shown below: Major Version Minor Version Build Number Revision [assembly:AssemblyVersionAttribute("1.

return 0. } . // Create the main window and run it Application::Run(gcnew Form1()).Application::SetCompatibleTextRenderingDefault(false).

POSTADO POR CHUVEIRO INTELIGENTE ÀS 16:02 0 COMENTÁRIOS DOMINGO. 14 DE JUNHO DE 2009 12/06 "Missão dada é missão comprida" . afinal.2 – POSTAGENS NO WEBSITE SEGUNDA-FEIRA. É um momento de amadurecimento muito propício para todos.5. possíveis vantagens do projeto que não foram suficiente exploradas. 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. mais doce é a vitória!" Documentação está na etapa final. 22 DE JUNHO DE 2009 22. todo o grupo discute constantemente sobre as possíveis melhorias que poderiam ter ocorrido.06 "Quanto mais amarga a batalha.

7 DE JUNHO DE 2009 . por causa do feriado. POSTADO POR CHUVEIRO INTELIGENTE ÀS 07:16 0 COMENTÁRIOS DOMINGO.Nesse final de semana prolongado. 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.

" .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. 27 DE M AIO DE 2009 23 . ajustes finos e testes) e documentação. POSTADO POR CHUVEIRO INTELIGENTE ÀS 17:43 0 COMENTÁRIOS QUARTA-FEIRA.05 "Seria a função do engenheiro vencer o equilíbrio?" .

.

e com isso esperamos resolver definitivamente esse problema. Foi refeita a ponteira do cabo.Descobriu-se o problema! Que fazia o circuito parar de funcionar sem motivos aparente. conserta-se uma coisa e a outra quebra sozinha!" . o circuito continua sem responder. um curto acontecia no cabo conector e as placas.05 "O equílibrio continua. POSTADO POR CHUVEIRO INTELIGENTE ÀS 08:34 0 COMENTÁRIOS 22 . A base que será usada e os encanamentos estão quase prontros. Novamente testado o programa.

indentificamos o problema como "mau instalação do driver" e a falta de um outro cabo que "desenvertia" o sinal serial.Com os novos PIC. 24 DE MAIO DE 2009 20 . Testamos o .O programa continua sem localizar a porta COM corretamente. foram novamente programados.05 "Nada que é bom vem de graça! " Conseguimos finalmente fazer o conversor serial funcionar. é como se o circuito não reconhece o computador e vice-versa! POSTADO POR CHUVEIRO INTELIGENTE ÀS 08:22 0 COMENTÁRIOS DOMINGO.

e os pic ficaram com inveja. 17 DE MAIO DE 2009 14-05 "Quando vejo a faixa de chegada. percebo que mais um esforço ainda é necessário!" . pois só o cabo serial estava recebendo atenção e resolveram não funcionar mais! POSTADO POR CHUVEIRO INTELIGENTE ÀS 16:57 0 COMENTÁRIOS DOMINGO.programa porém continua sem solução.

porém. DOMINGO. 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).05 "Começando a ver a curva da chegada" . o programa está com um erro. o qual irá controlar todo o sistema. não foi obtido sucesso. para detectar a porta de conecção USB. 10 DE MAIO DE 2009 08 . afinal.Foram testadas todas as placas com o programa. 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).

.

Começamos a estrutura pra o chuveiro. 17 DE ABRIL DE 2009 14 . o bruto pelos já.. O programa recebeu diversas modificações com o intuito de ter maior controle sobre toda a estrutura POSTADO POR CHUVEIRO INTELIGENTE ÀS 16:50 0 COMENTÁRIOS SÁB ADO. POSTADO POR CHUVEIRO INTELIGENTE ÀS 16:54 0 COMENTÁRIOS SEXTA-FEIR A.04 "Nada como um dia após o outro" . nos forçando a contruir uma amostragem de dados para construir a equação a partir de um gráfico. Estamos enfrentando problemas com o sensor de temperatura do chuveiro. as equações prontas não satisfazem o problema. 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. em C++. e também demos início a idealização de como posicionar as válvulas. e ja compramos o material para a estrutura de apresentação do chuveiro. 24 DE ABRIL DE 2009 20/04 ."Pensando como um chuveiro." Iniciou-se a programação do chuveiro. POSTADO POR CHUVEIRO INTELIGENTE ÀS 15:03 0 COMENTÁRIOS SEXTA-FEIR A. chuveiro e circuitos. com interface amigável..

.

9 DE ABRIL DE 2009 06 .Adaptamos os sensores de temperatura.04 "O deus da persistência nos agraciou por nossa intensa devoção!" . conseguimos testar as placas dos circuitos. POSTADO POR CHUVEIRO INTELIGENTE ÀS 17:07 0 COMENTÁRIOS QUINTA-FEIRA. 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.

pois a confecção das placas foi finalizada quase que no final do dia! . infelizmente. Porém.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. não houve tempo suciente para todos os testes necessários do material produzido.

Einstein" Tentamos novamente produzir as plaquinhas. 3 DE ABRIL DE 2009 03 .POSTADO POR CHUVEIRO INTELIGENTE ÀS 19:31 0 COMENTÁRIOS SEXTA-FEIR A. dessa vez porque fizemosu m espelhamento da imagem que não era necessário.04 "Só no dicionário que a palavra sucesso vem antes que trabalho . mas novamente não conseguimos realizar os objetivos. fazendo o circuito ficar invertido. Desta vez não houve aproveitamento decorativo e foi tudo para o lixo! POSTADO POR CHUVEIRO INTELIGENTE ÀS 20:11 0 COMENTÁRIOS .

02 .04 "Pondo os buracos nos eixos" .

perdemos algumas precisões. 26-03 "Aterrando idéias" . pois ao converter a imagem do circuito EAGLE em pdf. principalmente nas 8 perninhas do CI. 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.Nessa quinta tentamos corroer algumas placas para ja deixar finalizado algumas etapas. porem não fomos felizes nessa empreitada. Não havendo mais como remediar a situação.

a partir disso. porém. . a válvula solenóide passou a funcionar. estava sem defeito. Enquanto testávamos a válvula o módulo M2 deu alguns problemas.Conseguimos finalmente testar a válvula selonóide. ficou claro que só não estava aterrado!E. e após revisar todo o circuito. Houve a solda da porta de comunicação serial. sem responder às instruções do hyperterminal.

POSTADO POR CHUVEIRO INTELIGENTE ÀS 16:24 0 COMENTÁRIOS 25/03 "Indiana Comp em Busca do Motor de Passo Perdido" .

Conseguimos incrementar ao módulo M2 alguns sensores de temperatura que já foram testados com sucesso! POSTADO POR CHUVEIRO INTELIGENTE ÀS 15:58 0 COMENTÁRIOS QUARTA-FEIRA. 25 DE M ARÇO DE 2009 20/04 "renaming" . que foi encomendado para ser usado na etapa de potência que alimentará à válvula solenóide. infelizmente não conseguimos testar o motor de passo.Conseguimos dar início montagem do módulo M1.

POSTADO POR CHUVEIRO INTELIGENTE ÀS 10:43 0 COMENTÁRIOS 19/04 "Por falta de 1. necessitando acrescentar uma etapa de potência ao módulo M2.Descoberto que o problema do módulo M2 era o *. que foi testada. obtendo os resultados almejados. agora temos 2" . aparte do módulo M2 pois ela consumia muita energia. e fomos muito felizes com a situação. O integrante Tiago conseguiu uma válvula solenóide.rename(). começou uma seção de testes.

capacitor com funcionamento improdutivo. começamos a testar o módulo RS232-TTL porém não houve muito exito. com cabos em mãos.Nesse dia. O módulo M2 continua sem funcionar por motivo desconhecido. . pois não estava aterrado.

POSTADO POR CHUVEIRO INTELIGENTE ÀS 10:38 0 COMENTÁRIOS "Engatinhando" 18/03 .

POSTADO POR CHUVEIRO INTELIGENTE ÀS 10:16 0 COMENTÁRIOS Descrição Inicial Chuveiro Inteligente Esse blog foi criado com o intuito de divulgar as características. após definirmos como certo que o tema do projeto seria o Chuveiro Inteligente. O projeto será desenvolvidopor :    Carlos Roberto Remenche Junior. Demos início a montagem em protoboard do módulo M2. 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. 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. Denis Reimche Ott Rafael Antonio Grosko . soluções e novidades mais recentes do projeto integrado ministrado pelo professor Afonso Ferrei Miguel. problemas. professor de Resoluções de Problemas de Engenharia. o Chuveiro Inteligente.Nas primeiras semanas. mas nenhum dos equipamentos montados puderam ser testados por falta de cabo serial e válvula solenóide.

. Seria mais interessante ter 10 níveis. Um bom exemplo seria o maior quantidade de níveis de vazão. pois foi a dificuldade principal do grupo. se houvesse mais tempo para tal. A oportunidade de desenvolver essa idéia. e isso trouxe dificuldades imediatas como um todo. maquetaria e organização para desenvolver grandes projetos. programamos somente 3 níveis. Foi uma experiência enobrecedora ver o quanto de trabalho está por fazer para melhorar as condições da nossa sociedade. seria algo como “pouco”. “médio” e “bastante”. trouxe frutos de valorosos aprendizados de hidráulica. como todos eram da mesma área. e esse foi só um deles. para adquirir valorizada familiaridade com o mesmo. que comece focando formas mais inteligentes de disposição das peças. eletrônica. programação. a fim de economizar espaço. Digo fértil porque toda a dedicação que foi investida no trabalho. Pesquise e manuseie um catálogo de peças hidráulicas. de uso cotidiano. que traria perceptíveis melhorias para as pessoas de um modo geral. Outro ponto que poderia ser otimizado seria um controle e um método para aquecer a água até a temperatura desejada mais rápida. Ressalto sobre a importância das peças hidráulicas. Todo o grupo espera que se alguém resolva dar continuidade ao nosso projeto. É um projeto extremamente interessante. ajuda a enxergar soluções mais eficazes de encanamento e a economizar não comprando sobressalentes. Isso poupa tempo. Algumas características do nosso projeto poderiam ser melhor implementadas. ninguém tinha a familiaridade necessária com a área. traria maior conforto a escolhas de vazão. foi gratificante e proporcionou um amadurecimento dos integrantes do grupo além do esperado. desperdiçaria menos água enquanto espera-se a transição da escolha.6 – CONCLUSÃO Esse foi um projeto muito fértil. embora precisássemos de mais tempo para conseguir aprimorar todos os conceitos que a envolvem de maneira mais aprofundada e otimizada.