Consertando máquina de lavar Electrolux, com Arduino

Introdução

Neste post, vou mostrar como podemos resolver o problema de uma máquina de lavar com relógio analógico, que vivia dando problemas! Nunca entendi o que passava na cabeça dos engenheiros quando criaram (a uns 9 anos atrás) o projeto desta máquina, por que usar um relógio analógico para fazer algo que envolve programação? Daqui a pouco você vai entender do que estou falando.

A ideia de desenvolver esse projeto já existia ha muito tempo, mas claro, eu sabia que iria demorar muito para fazê-lo, e sabia que até aquele tempo era supérfulo, afinal a máquina estava funcionando.

O problema

O que ocorreu recentemente foi que a máquina parou de funcionar. Nesse período eu e a mãe já estávamos de saco cheio de levá-la na assistência e o pessoal trocar 60% dos componentes para depois encontrar o “real problema”. Resolvi então que iria consertá-la, seja lá como fosse.

A primeira tentativa foi fazer o conserto tradicional, tentando apenas arrumar somente o ponto do problema. O que ocorria era a carbonização entre os contatos do relógio mecânico (qual contém a programação das rotinas da máquina, ou seja, ele “sabe” quando ligar o quê).

Para entendermos melhor do que estou falando, vamos ver algumas imagens da máquina:

Foto frontal da máquina de lavar e seus respectivos botões de configuração
Relógio mecânico que contém a programação dos passos da máquina removido
Contatos internos do relógio. Repare que aqui temos 5 pinos, onde o do meio é o “pino mestre”, qual faz conexão com os outros 4

O problema que ocorre quando um conector carboniza é simples: ele não permitem mais a passagem de energia elétrica, fazendo com que o dispositivo conectado a ele (seja motor, lâmpada, etc) não faça seu papel, fazendo com que a máquina pare de funcionar, ou fique “meio maluca” – o que é mais provável.

Para ficar mais claro o que fiz nesse relógio, nas várias tentativas em consertá-lo, mostro abaixo as imagens que fiz em abril de 2010 (sim, esse problema já era bem antigo), quando “resolvi o problema” apenas lixando os contatos que estavam carbonizados.

Ponta de contato antes de ser lixada
Ponta de contato lixada (do outro lado)

Depois de muitas tentativas em consertar o relógio, verifiquei que não adiantava, afinal ele voltava a carbonizar em poucos meses de uso. A solução seria então trocá-lo por um novo: ótima ideia! Foi aqui que minha antiga ideia finalmente mostrou-se útil.

Quando liguei na loja autorizada de minha cidade (Videira – SC) para verificar o preço, eles falaram que esse modelo de relógio agora mudou, “é maior” disse-me a vendedora. Ok eu pensei, então pedi quanto cobrariam para trocá-lo. Antes de me passar o valor, porém, fui informado que para trocar o relógio precisaria também trocar todo o chicote da máquina (chicote eles se referem aos fios de conexão internos), certo, então questionei, por que trocar? Não dá para simplesmente adaptar ao novo relógio?

Infelizmente a resposta foi não e o orçamento final iria passar dos 200,00 reais, que apesar de ser um custo razoável para esse tipo de conserto, eu julguei não valer à pena, simplesmente pelo fato da loja ter sido tão inflexível. Poxa, desde quando não dá para adaptar??? Aqui veremos que podemos fazer muito mais do que uma simples adaptação de “chicote”…

A solução

Confesso que fiquei até feliz por não ter dado certo o esquema com a loja. Não que eu não quisesse resolver o quanto antes o problema, mas é que assim seria inevitável eu colocar minha ideia em prática hehe.

Feita as devidas negociações de tempo com minha mãe, resolvi tirar do papel “a tal ideia”. Pensei inicialmente: “Basicamente preciso mapear todas as conexões feitas pelo relógio mecânico e esse deverá ser meu maior problema”. Erroneamente porém, não tive nenhum grande problema, somente pequenos pontos de ajustes que você irá conferir depois.

O primeiro passo – Mapear os valores do relógio mecânico

Parti logo para o que julgava ser o mais difícil, afinal defendo a ideia de que fazendo o mais difícil o resto é mole e se seu projeto não parar nessa primeira etapa então ele vai dar certo!

O princípio de funcionamento do relógio mecânico, ou o seletor de programas é muito simples. Ele contém 4 camadas de chaveamento, onde cada camada possui chaves independentes acionadas por um “rotor principal”. Esse rotor não tem nenhum segredo. Alguém lembra daquelas caixinhas de músicas?

“O piano” da caixinha de música. Fonte: Wikipedia

O princípio de funcionamento é mesmo: “programação mecânica”. A música da caixinha era gravada em um rolo, qual girava em uma mesma velocidade enquanto havia força na mola em que se dava a corda.

Neste rolo eram presas pequenas esferas quais tocavam de forma sincronizada as astes de ferro que vibravam em uma determinada frequência. Todas juntas reproduziam uma música maravilhosa, não preciso falar do incrível dançar da bailarina, preciso?

O que fiz, foi então conectar fios em cada chave do relógio mecânico. Podemos ver essas chaves como simples relés, onde, a maior parte delas, possui os estados NA (normalmente aberto) e/ou NF (normalmente fechado). Esses fios então foram conectados à leds, indicando o exato momento em que a chave acionou. Aqui vemos uma utilidade sem igual da protoboard: simples e prática!

Desta forma eu coloquei o “ponteiro” do relógio mecânico no ponto qual julgava ser o “minuto 0”. Observei que esse relógio tem extatos 60 pontos (cada ponto é “executado” a cada 2 minutos), então cada ponto tem uma sequência de acionamento de chaves, e era exatamente isso que eu precisava mapear.

O tempo de acionamento de cada estágio é de 2 minutos, como dito anteriormente. Ele é sincronizado com os 60Hertz da rede elétrica, quais fazem um motor girar levando uma espécie de pá para frente e para traz e essa pá é que vai aos poucos girando o ponteiro do relógio mecânico. Admito que o esquema é muito engenhoso e de tirar o chapéu. O problema é que eu acabei perdando uma pequena mola que estava ligado nessa pá, não permitindo que eu reproduzisse aqui seu funcionamento. De qualquer forma, acredito ser muito mais fácil programar isso tudo :) .

Nomeei as chaves de cada nível do relógio em A, B, C e D. Para o primeiro nível temos 4 interruptores: ou seja: A1, A2, A3 e A4. O Aref é o pino “mestre” que falei antes, qual faz conexões independentes entre os outros, seguindo essa lógica: A1 OR A2 AND A3 OR A4. Isso quer dizer que Aref está conectado com A1 ou com A2 e ao mesmo tempo pode estar conectado com A3 ou A4.

O mesmo ocorre para as chaves B1 OR B2 AND B3. A chave C funciona de forma mais simples: Cref está conectado apenas em C1 ou em C2. A chave D1 é a mais simples: está ligada ou não.

Fios soldados no relógio mecânico com respectivas legendas
Leds na protoboard correspondendo a cada chave do relógio mecânico
Rascunho do mapeamento das chaves

Tendo feito essas conexões físicas, tudo que precisei fazer foi posicionar o ponteiro em cada estágio, e anotar os valores lidos em cada led. Coloquei tudo isso em uma planilha e depois apenas à converti em uma matriz booleana de 10×60.

A programação final da máquina pode ser conferida nas imagens a seguir:

Programação do relógio em uma planilha

E aqui a conversão dos dados acima para programação:

Programação do relógio – em linguagem C

Feito isso a primeira parte estava concluída, afinal toda a lógica da máquina, antes mecânica, agora completamente mapeada para um programa de computador!

Segundo passo – Construir o circuito elétrico

Tendo feito o mapeamento, o que precisei fazer então foi a parte física que substituiria os contatos do relógio mecânico. Como dito anteriormente, ele não passa de uma série de relés, então resolvi fazer o óbvio: usar relés!

Humm, mas aí vem a pergunta: “Paulo, não dá para otimizar isso com os famosos TRIACs BTA?”. Droga, se você pensou isso tem completa razão. Infelizmente, preciso admitir aqui que não fiz um estudo tão aprofundado da máquina para saber exatamente quais relés poderia ter substituido por BTAs, mas tenho certeza de que a maioria deles poderia ser.

Porém, como eu tinha uma urgência em terminar o projeto, usei o mais fácil: simples relés de acionamento. Esse projeto tem várias possíveis melhorias, mas como um “eterno protótipo” está muito funcional até o momento, depois darei mais detalhes sobre a inesperada estabilidade dele.

Definido os atuadores, o que fiz foi então separar todos os componentes que iria precisar na montagem da placa. Entre eles temos vários relés, onde alguns são de 40A e outros de 15A, vários resistores, regulador de tensão 7805, bornes de conexão na placa, transistores BD137 (para acionar os relés), diodos de proteção contra corrente inversa causada pela bobina do relé, um display LCD 16×2 que removi do shield que o professor Herculano havia me emprestado, obrigado Herculano! (Parece que depois de alguns meses “apareceu” um irmão gêmio do Shield e este foi devolvido com segurança hehe). E claro, o mais importante: o chip do Atmega328 com seus respectivos componentes básicos como oscilador e capacitores 27pf (quais não aparecem na foto).

Componentes separados para montar a placa
Ok, admito, adoro tirar fotos com peças…
Layout inicial da placa

Após definir o layout básico e ter separado todos os componentes era hora de começar a colocar a mão na massa. Não vou postar aqui o esquema do circuito elétrico até porque não o fiz, pois existem muitos tutoriais na internet mostrando como acionar relés e outros componentes através da lógica TTL (5V). Aqui você pode encontrar um excelente tutorial do Rogercom que explica como fazer isso. Você pode também se inspirar na placa Tomad@ da Globalcode.

Eu soldando os componentes na placa ilhada
Componentes soldados na placa ilhada
Trilhas feitas através de fios e solda na placa ilhada

Como removi o display LCD de seu shield (não faça isso ok? eu quase o danifiquei fazendo, é melhor ter paciência e comprar um display avulso), precisei então montar uma base para ele. Aí entrou em ação meu modo gambiarra hehe, e é nessas horas que fazemos as melhores coisas: Encontrei um AP queimado (eu não consigo jogar fora essas coisas) e dei uma analisada em sua capa. Logo percebi que as hastes que parafusam um lado ao outro da capa poderiam perfeitamente ser usadas como base do meu display. Acompanhe o processo:

Ap aberto e suas hastes
Usando soldador para remover a haste do ap
Haste pronta para ser removida

E aqui a parte final:

Todas as hastes removidas e parafusadas no display
Analisando o próximo corte – para fazer a base principal do display lcd
Display lcd 16×4 perfeitamente montado em sua nova base

Depois de montada toda a placa, desenvolvi uma interface de programação, afinal não vale à pena deixar num projeto desses um sistema de gravação completo (FT232BL e etc), pois ele será raramente usado. Tendo isso em vista, com 5 pinos criei uma simples interface de programação, com comunicação serial, alimentação e pino de reset. Liguei essa interface ao meu adaptador USB -> RS232 (que acabou virando um gravador serial excelente graças a adição de 1 capacitor 104) e a partir desse ponto já podia gravar software no chip Atmega. Repare que nesta imagem estamos testando tando o display LCD 16×4 quanto os relés (e seus respectivos LEDs):

Placa ilhada com todos os componentes funcionando e o gravador Serial conectado

Na foto temos todos os componentes montados e funcionando. Não cabe à este post explicar como usar o Arduino diretamente na placa, existem tutoriais explicando isso na internet.

Veja que usei um regulador 7805, que reduz, neste projeto, 12V da fonte de alimentação para 5V necessários para alimentar o Atmega 328. Atenção! É essencial usar dois capacitores para esse regulador de tensão, do contrário você não terá 5V estabilizados na saída! (apanhei muito antes de cair a ficha de que deveria seguir o esquema indicado pelo fabricante. Aqui um tutorial em português).

Feito isso a placa estava praticamente pronta, faltando apenas cortá-la no tamanho correto para colocá-la em uma caixa adequada.

Terceiro passo – Construindo a caixa para acoplar a placa ilhada e seus componentes

Uma vez desenvolvida a placa e testada, eu simplesmente teria que fazer um bom suporte para acoplá-la. Não sou muito bom e fazer coisas bonitas, e como adoro madeira, peguei logo alguns pedaços de MDF que tinha aqui em casa, uma serrinha de serrar ferro, uma régua um canetão e fui cortar a caixa.

O processo de construção de uma simples caixa não envolve muito segredo. Basicamente precisamos de um fundo e 4 “paredes”, veja:

Placa ilhada cortada no tamanho correto e pronta para ser usada como medida
Medidas feitas no MDF
Caixa montada e pronta para ser pregada (com pregos 9mm!)

Quarto passo – instalação da placa na máquina

Aqui as coisas começaram a ficar incrivelmente emocionantes, afinal estava tudo pronto para dar certo, nessa altura o software já estava construido e rodando (Apesar de eu não adentrar no funcionamento do programa, disponibilizo o código fonte mais à frente caso você queira estudá-lo). Tinha tudo para dar certo eu pensava, afinal só troquei umas chaves analógicas por outras “digitais”. Felizmente eu estava certo, mas depois você verá o video final.

O que eu precisava fazer agora era cortar fios de tamanho bom para ligar a máquina até a placa. A distância dos fios foi de 1 metro aproximadamente. A sobra é útil quando precisa-se limpar atrás da máquina ou fazer alguma manutenção. Comprei fios de várias cores para facilitar a conexão deles no circuito.

Algumas conexões da máquina exigiam mais corrente e para estas usei os relés de 40A e um par de fios para fazer a conexão com a placa, isso tudo para garantir que transferência de corrente não seria um problema. Provavelmente eu tenha superdimensionado o circuito, mas assim trabalhei mais tranquilo.

Confira as imagens:

Fios soldados – dois fios para maior transferência de corrente
Fios conectados à placa ilhada
Conexões dos fios nos bornes da placa

Após conectado os fios na placa o próximo passo foi conectá-los à máquina! Finalmente, uma interface! Para não fazer um sistema muito intrusivo, e facilitar futuras manutenções, revolvi usar conectores na máquina. Aqui é o ponto que a loja disse “não dá para adaptar”. Siiim, dá sim, veja nas fotos abaixo.

Foi necessário fazer um pequeno buraco na capa da máquina (sorry mama) para a passagem dos fios. Feito todas as conexões, meu ambiente de testes estava montado! O notebook ao lado foi usado para acompanhar o retorno serial feito pelo programa, informando o que extamente estava fazendo e também para fazer atualizações do programa “em tempo real”. Nos videos isso fica mais claro.

Fios adaptados ao conector da máquina, sim, é possível!
Fios passando pela capa plástica da máquina
Ambiente de testes

Quinto passo, Fazendo tudo funcionar!

Nessa etapa é que os nervos ficam a flor da pele! Em teoria está tudo pronto, mas você com a conhecida experiência de programador, sabe: vai dar pau! hehe. E realmente, um programa nunca funciona de primeira! Mas isso é normal. Confira no video abaixo como foi emocionante fazer os testes.

Por fim, o sistema instalado, terminado e funcional!
Veja que ele gera uma certa interação com a mãe. Futuramente pode-se desenvolver um comportamento para a máquina do tipo “ainda quer lavar?”, “estou exausta”, “Como é bom ser uma máquina de lavar roupas” e assim por diante.

Placa instalada na prateleira e rodando o sistema
Máquina dando boas vindas para a mãe
Máquina feliz por ter terminado seu trabalho
Máquina finalizada e em uso

Código fonte do Programa

Como dito anteriormente, não vou aprofundar-me no código fonte, até porque ele está bastante fácil de entender. Fique atento, esse código não está otimizado ok? Peço desculpas aos desenvolvedores avançados…

Apesar de simples, sempre tem muito que podemos aprender. Esse sistema trabalha com a EEPROM do Arduino, afinal caso seja aberta a tampa da máquina ou acabe a luz, o sistema se desliga, e precisa saber onde estava para continuar seu trabalho.

Ele também trabalha com o display LCD, qual você poderá notar a simplicidade que é em se trabalhar. Veja também que o programa não usa o método loop() do Arduino. Bons estudos!

/*
  Programa de controle para maquina de lavar
  Paulo Marcos Trentin
  em: 04-10-11
  terminado versao 1.0 as 16:26 - coisas a melhorar
*/
 
#include <EEPROM.h>
#include <LiquidCrystal.h>
 
//  Controle dos pinos atuadores
#define pinA1 A4
#define pinA2 4
#define pinA3 3
#define pinA4 5
#define pinB1 7
#define pinB2 A2
#define pinB3 A3
#define pinC1 A0
#define pinC2 6
#define pinD1 A1
#define pushButton 2
 
//  Dados para controle da EEPROM
#define WORK_STATE 0
//  A = 0, B = 1, C = 2, D = 3, E = 4, F = 5
#define PROGRAM_LETTER 1
//  Controle de reinicio. Usado para exibir mensagens
#define REBOOT 2
 
//  Define variaveis globais
int letter = 0; //A
 
//  Matriz da programacao da maquina (matriz de 10x60)
boolean states[][60] =  {   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0},   {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0},
{1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,0,1,1,1,1,1,1,1,1,1,0},
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1},
{0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,0},
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
                          };
 
//  Define sequencia de estagios para cada letra (matriz de 6x2)
int letters[][2] = { {1,15},  //A
                      {16,29}, //B
                      {30,37}, //C
                      {38,41}, //D
                      {42,50}, //E
                      {51,60}  //F
                    };
/*
  min 42 e 43 esvazia agua do cesto
  44 centrifuga
  47 enche de agua
 
/*
/*  Obtem a letra de acordo com seu valor decimal */
char* getLetter()
{
  byte letter = getState();
 
  for (int i = 0; i < 6; i++){       if (letter >= letters[i][0] && letter <= letters[i][1]){
        return getCharLetter(i);
      }
  }
}
 
char* getCharLetter(int i)
{
  switch(i){
    case 0:
      return("A");
    case 1:
      return("B");
    case 2:
      return("C");
    case 3:
      return("D");
    case 4:
      return("E");
    case 5:
      return("F");
  }
}
 
//int vectorPins[] = {A4,3,4,5,6,7, A0, A1, A2, A3};
int vectorPins[] = {pinA1, pinA2, pinA3, pinA4, pinB1, pinB2, pinB3, pinC1, pinC2, pinD1};
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);
int pins = 10;
 
void setup() {
  Serial.begin(9600);
 
  //  Inicia LCD
  lcd.begin(16, 2);
 
  //  Define pinos como saida
  for (int i = 0; i < pins; i++){     
    pinMode(vectorPins[i], OUTPUT);   
  }   
  
  //  Usada em manutencao para inicio da maquina   
  //eraseEEPROM();   
  
    //  Verifica estado atual   
    int state = getState();   
      if (state == 60){     
        //  Imprime mensagem de boas vindas     
        printStartupMessage();     
        //  Deixa a maquina em estado de descanso (passo 60)     
        setPins(60);   
      }else{     
        int value = EEPROM.read(REBOOT);     
        Serial.print("eemprom value: ");     
        Serial.println(value);     
        if (value == 0){       
          for (int i = 5; i > 0; i--){
            lcd.clear();
            lcd.print("Voltando ao");
            lcd.setCursor(0,1);
            lcd.print("trabalho em ");
            lcd.print(i);
            lcd.print("...");
            delay(1000);
     
            if (checkButton()){
              delay(500);
              if (!digitalRead(pushButton)){
                setState(60);
                lcd.clear();
                lcd.print("Trabalho");
                lcd.setCursor(0,1);
                lcd.print("cancelado");
                delay(2000);
                break;
              }
            }
      }
    }else{
      //  Desativa flag
      EEPROM.write(REBOOT, 0);
    }
 
    boolean control = true;
    if(getState() == 60){
      control = false;
    }else{
      lcd.clear();
      lcd.print("Vamos la!");
      delay(1500);
    }
 
    while(control){
      control = newStep();
      //  Aguarda 2 minutos
      Serial.print("Aguardando 120 segundos: ");
      for (int i = 1; i <= 120; i++){         delay(1000);         Serial.print(i);         Serial.print(" ");       }       Serial.println("Ok");     }   }   boolean control = true;   while(control){     if (checkButton()){       delay(500);       if (!digitalRead(pushButton)){         delay(500);         if (!digitalRead(pushButton)){           //  Informa ao usuario o inicio da rotina           lcd.clear();           lcd.print("Iniciando");           lcd.setCursor(0,1);           lcd.print("letra ");           lcd.print(getCharLetter(letter -1));           lcd.print(" ...");           Serial.println("Clicou > 1 segundo");
 
          //  Executa o inicio da rotina
          setState(letters[letter -1][0]);
          delay(2000);
 
          //  Reinicia rotina do programa para rodar a configuracao
          EEPROM.write(REBOOT, 1);
          delay(1000);
          asm volatile ("jmp 0x0000");
        }
      }else{
        //  Controla o tamanho de letter
        if (letter == 6) letter = 0;
 
        lcd.clear();
        lcd.print("Rotina ");
        lcd.print(getCharLetter(letter));
 
        //  Incrementa letter
        letter++;
      }
      Serial.print("Clicou");
    }
  }
}
 
void printStartupMessage()
{
  //  Verifica se a maquina estava lavando algo
  lcd.print("Oi Neusa, vamos");
  lcd.setCursor(0,1);
  lcd.print("lavar?");
}
 
/*
  Manipula botao de interacao com o usuario
*/
boolean checkButton()
{
  int value = digitalRead(pushButton);
 
  if (value == 0){
    Serial.println("Clicou");
 
    //  Apenas faz beep
    beep();
    return true;
  }
 
  return false;
}
 
/*
  Zera a EEPROM do Atmega8/168 (512 Bytes)
*/
void eraseEEPROM()
{
  for (byte i = 0; i < 255; i++){     
  EEPROM.write(i, 0);   
}  

//  Inicia maquina desligada (estado = 60)   
EEPROM.write(WORK_STATE, 60);   
  //  Define letra A como ativa   
  EEPROM.write(PROGRAM_LETTER, 0);   
  //  Ajusta flag   
  EEPROM.write(REBOOT, 0); 
} 
/*   Salva estado atual do programa na EEPROM.   O estado e armazenado em passos, 1 - 59 no primeiro endereço da memoria (0) */ 
void setState(byte value){   
  Serial.print("Salvo estado WORK_STATE: ");   
  Serial.println(value, BIN);   
  EEPROM.write(WORK_STATE, value); 
} 

/*   Le o estado atual do programa */ 
byte getState(){   
  return EEPROM.read(WORK_STATE); 
} 

/*   Avanca um passo no programa */ 
boolean newStep() {   
  //  Obtem o passo atual   
  int state = getState();   
  //  Exibe no lcd o que esta fazendo   
  lcd.clear();   
  lcd.print("Executando");   
  lcd.setCursor(0,1);   
  lcd.print("tarefa ");   
  lcd.print(getLetter());   
  lcd.print("  Min:");   
  lcd.print(state);   
  if (state >= 60){
    //  Finaliza programa
    Serial.println("Programa encerrado.");
    lcd.clear();
    lcd.print("Uffa,");
    lcd.setCursor(0,1);
    lcd.print("       terminei!");
    setPins(60);
 
    delay(1000);
 
    delay(500);
    beep();
    delay(200);
    beep();
    delay(200);
    beep();
 
    return false;
  }
 
  //  Executa fisicamente o passo (aciona reles)
  setPins(state);
 
  //  Se o passo for 1 ou 47, atrasa 5 minutos
  if (state == 1 || state == 47){
    Serial.print("Atrasando 5 minutos para encher de agua: ");
 
    for (int i = 1; i <= 300; i++){
      Serial.print(i);
      Serial.print(" ");
      delay(1000);
    }
    Serial.println(" Ok");
  }
 
  //  Avanca e salva o passo na memoria
  Serial.print("State: ");
  Serial.println(state);
  setState(++state);
 
  return true;
}
 
void setPins(int state){
  for (int j = 0; j < 10; j++){
    boolean value = states[j][state -1];
    Serial.print(value,BIN);
    digitalWrite(vectorPins[j], value);
  }
  Serial.println();
}
 
void beep() {tone(A5, 900, 100);}
 
void loop() {}

Conclusão

Esse projeto foi iniciado no dia 2 de outubro de 2011 e teve sua conclusão 7 dias depois. Ele significou muito para mim, pois identificar um problema, desenvolver e validar uma solução eletrônica sempre foi algo complexo e que até então não havia conseguido fazer algo de maneira eficaz.

Quando mais novo (12 anos em diante) até esse projeto, sempre tive enormes dificuldades em terminar minhas ideias (exceto é claro minha carregadeira feita aos 13 anos, que não tirei nenhuma foto :( – as câmeras digitais não eram populares naquele tempo). Sempre comecei muito empolgado e depois acabava desistindo seja qual for fosse o motivo – normalmente tinha uma ideia melhor e desmontava a anterior para fazer a próxima (falta de peças hehe). Então, se você é assim, muito empolgado em desenvolver algo e com o passar do tempo trabalhando no mesmo projeto se sentir desanimado, lembre-se: eu passei muitas vezes por isso, o importante claro é continuar, continuar, continuar. Um dia chegamos lá!

Dica:
Quando for desenvolver qualquer tipo de projeto eletrônico, separe-o em etapas bem definidas, depois execute cada uma como se fosse a mais importante e não tenha pressa em testá-lo! Desfrute cada pedaço do todo com muita paciência. As chances de concluir sua ideia só aumentarão.

O que mais me impressionou foi a estabilidade do “eterno protótipo”, pois 4 meses depois, a máquina continua lavando roupas, sem reclamar e sem travar! Eu imaginei que iria ter muita dor de cabeça ainda, mas repito: fiquei impressionado com a estabilidade do Atmega 328. Não tenho experiência com PIC ainda, mas será que com um circuito “tão pobre” como o desenvolvido aqui ele teria a mesma estabilidade? Fica aberta essa questão para daqui alguns meses/anos eu responder.

Espero sinceramente ter lhe ajudado em algo, obrigado pela paciência em ler até aqui.

Agradecimentos

Obrigado mãe, por ter confiado em mim e ter tido paciência de ficar 7 dias sem lavar roupas aguardando, sem garantias, o desenvolvimento e teste do projeto que iria consertar a máquina.

257 Comments

  1. vc não é fraco,estava procurando alguma solução para a maquina d minha mae q e igual a essa ,nao vou fazer esse esquema que fez pq nao tenho capacidade,ms vou lixar as pontas de dentro d relogio,valeu ae e parabens pelo projeto

  2. Parabéns Garoto.
    Já tive também muitos problemas com estes relógios, uma vez para a mulher não estragar as unhas, coloquei um banco de chaves margirus no lugar aí que os problemas aumentaram, pois tive que dar um curso de uma semana para ensina-la as sequencias para poder lavar a roupa, Foi um horror!

    Tens futuro!
    Abraços

  3. bom dia Paulo adoro esses projetos de eletrônicas .e fiquei maravilhado com o seu projeto evolutivo, muito bacana mesmo , parabéns. vc teria como me dar uma luz no túnel do tempo ? pois tenho uma maquina um pouco mais antiga do que a sua. eo seguinte o rato entrou dentro da maquina querendo fazer ninho . dai ele puxou um pedaço de pano e enrrolou nos fios e dai o problema. quando o motor foi centrifugar puxou o pedaço de pano junto com os fios , e arrancou todos do terminal .os fios são numerados mas os os teminais (ou pinos) não são.vc teria alguma luz .forte abraço.e pode rir da estória de certa foma e engraçada

    claudiosouzacr@gmail.com

    1. hehe, é engraçado mesmo Claudio. Mas acontece, já ouvi relatos parecidos por aqui…
      Recomendo obter o manual técnico da máquina, pois é nele que você encontra todos os detalhes de fiação e motores dela. Acredito que é a maneira mais eficiente de resolver esse problema.

  4. Prezado Marcos, sua ideia de utilizar o sistema Arduino é louvável, e ainda fica mais robusta ao não deixar instalado o sistema eletrônico na máquina, o que evitaria danos causados pela excessiva umidade. Mas tenho feito aqui em Recife o seguinte quando tenho problemas com contatos oxidados como foi seu caso: 1) Nada de lixar os contatos! isso é um crime! O certo a se fazer é dar um polimento com produtos limpa prata (Kaol Silvo Brasso etc) e aplicar uma camada de vaselina sólida para a proteção dos contatos (esqueça também os limpa-contatos). Sei que no seu caso não existe mais o timer original, mas numa próxima situação, experimente isso. Sou técnico em eletrônica há 27 anos, e de vez em quando aparece algum sistema com os contatos oxidados e sempre uso essa técnica que, apesar de trabalhosa, é infalível. (Todo bom remédio é amargo…)

  5. rapaz, parabéns… tenho uma maquina igualzinha a tua… ou de sua mãe… poderia me ajudar? quero fazer com que ela faça apenas rodar e nao ficar tanto tempo parada… seria tipo rodar 10 minutos e depois enxaguar…. entrar agua, rodar e centrifugar… abraço s e felicidades

  6. Estava procurando no google outro tipo de dica para conserto de lavadora (não é no relógio), mas como sou fã do Arduino não resisti e tive que ler sua aventura até o final.
    Parabéns por levar a ideia até o fim. A caixa presa na prateleira não tem nada de protótipo!
    Por experiência própria, com uma pressão de prazo vinda do “product owner” diminui a chance do projeto morrer no caminho…rs
    Até imagino sua mãe lá pelo quinto ou sexto dia começando a contar o dinheiro para comprar outra maquina.

  7. Senhor boa noite. Também estou aproveitando uma maquina de lava consul. Todos os tempos ja programei, estou tendo dificuldade é em controlar o motor para realizar os movimentos de lavar. Estou utilizando a interrupção externa do pic para detectar a passagem do zero mas tudo indica que não tenho controle e nem torque em baixa velocidade. Obrigado se puder me ajudar desde já agradeço.

  8. Como é bom termos um pouco de conhecimento e sairmos destes esurpadores que se chamam de técnicos, basta vermos como seu trabalho da maioria é grosseiro. Assim, verificou como é possível salvarmos diversos eletrodomésticos que na maioria dos casos irão fazer parte dos lixões nas grandes cidades. Tive uma experiência com minha máquina de lavar, trocando todas as peças e mesmo assim a mesma não fazia centrifugação. Verificando os cabos elétricos que alimentavam o motor, achei um cabo deslocado de seu plug de conexão. Apenas com sua troca e solda a máquina voltou a funcionar normalmente, quase nova, sem barulho e sem vazamento no seu eixo central. Pena que a maioria da população não tenha coragem de enfrentar o problema de frente, assim teriam um gasto menor e sua máquina teria as peças originais.

  9. bom dia paulo marcos , sou de americana eu tenho 65 anos voce pode me ajudar a ver isto para mim , por favor me da uma dica ,diser o purque a minha maquina da eletrolux de 8k que eu tenho deis de 2005 que ja fais 10 anos ele comesou da um poplema , ela quando vai sintrifugar comesa a faser um barulho terivel de subiar , e de ves em quanto ela comesa só virar de um lado , voce pode me diser si é dificio de arumar

  10. Parabéns, vc é uma pessoa de futuro promissor, sou técnico, em refrigeração e eletricista, com conhecimentos em eletrônica, e sempre achei e pensava em fazer uma coisa semlhante, para comandar aquelas maquinas mais antigas. Aí veio a erá das placas digitais, e guardi na gaveta, mas valeu mesmo. Continue assim e coloque Deus a tua frente, abraços..

  11. sou eletricista ,tenho um pouco de conhecimentos em automaçao ,gosto desse tipo de trabalho ,voce é muito criativo,e de talento ,admirável seu trabalho .minha maquina ,centrifuga mas nao agita ,turbo limpeza 9 kilos ,dessa antiga ,pode me ajudar?eletrolux,obrigado

  12. A minha maquina que eu tenho em casa ela não quer fazer o processo de sentrifugação quando chega esta etapa ela tira a agua e fica por alguns minutos assim e depois desliga e não sentrifuga ….

  13. Mandou bem, cara!
    O que o Gilberto Silva Lopes comentou é a pura verdade: seu futuro é promissor. A princípio, pode parecer que você gastou um tempo exagerado e desnecessário para arrumar uma simples máquina de lavar, mas a verdade é que todo o conhecimento adquirido por você durante esse e outros projetos de “hobby” com certeza vão ter uma serventia muito mais nobre no futuro.
    Hoje foi a máquina de lavar que você controlou, mas amanhã pode ser o anel de armazenamento de elétrons do Laboratório Nacional de Luz Síncrotron.
    Sucesso!

  14. Caro Trentin,
    Espero que continue com a mesma vontade que tinhas em 2012, e que tenha se realizado profissionalmente. De tempos em tempos passo aqui só para relembrar teu projeto. Hoje ele seria sem dúvida muito mais fácil, compacto e barato de fazer com o uso de , por exemplo, um Garagino e um shield com vários relés, tudo por talvez por menos de uns 100 reais.
    Fiz um projeto parecido automatizando um tanquinho (4 relés), que hoje faz tudo, e mais ainda, que uma lavadora convencional, exceto centrifugar, é claro.
    Desejo sucesso para voce, o mundo precisa de pessoas criativas e inteligentes.
    Um abraço.
    P.S.: Voce trabalha ainda hoje profissionalmente nessa área ou exerce outra atividade não relacionada ?

    1. Boa noite Lauro,
      lembro-me do seu comentário e publicação do meu blog no laboratório de garagem, é sempre bom revê-lo por aqui!
      Concordo, hoje tudo está mais fácil, o que é ótimo. Fico muito feliz e encantado com a evolução da eletrônica, como exemplo o módulo esp8266 que é um módulo wifi completo com um super microcontrolador em um chip só.
      Agradeço novamente seu contato, e fico feliz que tenha automatizado sua lavadoura também, muito legal isso!

      Eletrônica sempre foi um hobby para mim, desde criança fui apaixonado por ela. Mais tarde ao encontrar a programação me apaixonei por ela também hehe, e hoje e dela que vem meu sustento: possuo uma empresa de desenvolvimento de softwares para web. Ainda gosto muito de eletrônica, mas cada vez mais para diversão e resolver um problema aqui e outro ali.

      E você Lauro, como andam seus projetos com eletrônica, continua os estudos e experimentos?

      1. Alo Trentin,
        Meu tanquinho continua perfeito, com upgrades no software de tempos em tempos para melhorar a performance.
        Meu tempo para dedicar a “cachaça” do software e da eletrônica anda bem escasso, pois sou empresário e não é raro trabalhar sábados e até domingos esporádicos.
        Já sou “antigo”, fiz 60 anos a pouco, e por isso gosto de algumas velharias, mas especialmente o desafio de automatizá-las ou reviver coisas que não funcionam mais.
        Meu proximo(quando?…) projeto é fazer um daqueles (bem) velhos “barômetros” de parede que tinham mostradores redondos analógicos mostrando temperatura, umidade e pressão atmosférica. Sou motociclista (não motoqueiro!) e acompanho muito atentamente as condições do tempo para organizar e fazer meus passeios.
        Hoje com um arduino, ou similar, e dois sensores, e 3 servos é perfeitamente possível fazer isso. Minha idéia seria usar servos para mover os ponteiros. E como atualização e valioso upgrade/modernização as medições a cada minuto ou hora seriam armazenados e poderiam ser “chamadas” com o pressionar de um botão, mostrando a variação dos valores medidos nas últimas 6, 12 ou 24 horas…
        Está na fila de espera. Mas, se um dia se você se interessar e puder meter a mão na massa eu patrocino todo o material que precisar para desenvolvimento do projeto, ok?
        Um grande abraço. Espero que voce nunca perca seu espírito curioso e de aceitar desafios mesmo que seja para solucionar um pequeno problemas.

  15. Você é um “doido varrido” eu estava procurando um POST para consertar essa mesma máquina, mas sem chance de fazer o que fez com essa máquina de lavar.
    Você praticamente criou uma nova máquina!! kkkk

    Abraços e parabéns pelo projeto!

  16. Paulo, bom dia.
    Sou de Recife e busco fazer um curso de manutenção e conserto de máquina de lavar roupas. Mas não encontro presencial aqui em minha cidade. Você tem o curso em apostilas, ou cd/dvd? Se sim, me envie por favor preço ou me indique, caso saiba, algum curso. Abraços,

    Adivan-Recife

  17. pode me ajudar? desejo tirar os controle de minha maquina e deixar um botao para ficar só batendo a roupa, outro pra centrifugar (anula o botao anterior) e outro pra desligar… ou uma chave com tres posições… poderia me dizer quais fios devo ligar direto.. entre um deles um interuptor…. minha maquina e uma eletroluz lm08… obg ja que vc tem os fios fora da maquina creio ser mais facil saber quais necessito. bgg e parabens

    1. Olá Roldao, faz algum tempo já que fiz este projeto, então não consigo hoje lhe ajudar. O que recomendo é que baixe o manual técnico da máquina. Lá você verá todos os motores e seus fios para serem acionados.
      Vale lembrar que não basta apenas ligar ou desligar alguns fios, pois a máquina é mais complexa que isso, uma vez que ela possui sensores/válvulas/freios.

  18. Parabéns pela perseverança e pela habilidade. Como você disse, é fácil começar um projeto e deixá-lo pela metade, tenho vários assim. Acho que o segredo é quando a gente PRECISA resolver o problema, pois no seu caso, imagina deixar a mãe sem máquina! Nem pensar, hehe, pra isso vale a pena até virar noites em claro pra terminar E pra deixar bem feito! Novamente, parabéns!

  19. Parabéns. Talentos assim que o Brasil precisa para andar para frente.
    Que você use esse dom que Deus lhe deu para fazer o bem, sempre.
    Deus te abençoe, em Cristo Jesus.

Deixe uma resposta para Aristides Cancelar resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *