Medidas feitas no MDF

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.

186 ideias sobre “Consertando máquina de lavar Electrolux, com Arduino

  1. Juarez

    Ola!
    Primeiramente parabéns!
    Ficou bem interessante seu projeto…só uma questão como você insere os dados de entrada para fazer a seleção do tipo programação? Como por exemplo: economica, enxague, centrifugação…

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Juarez,
      Desculpa a demora em responder. Muito obrigado pelas considerações!

      Então, a entrada de dados é feita pelo único botão que fica no lugar do relógio. Apertando-o ele altera os programas, que nesta máquina são organizados em A,B,C,D,E e F. Ao segurar o botão pressionado a máquina inicia a rotina selecionada. É bem intuitivo! :)

      Responder
  2. Emerson

    Pô cara, parabéns. Meu sonho é conseguir fazer isso. Transformar um negocio mais velho, que tem a parte mecanica boa em um novo de ultima tecnologia. Agora vc conecta a maquina no computador e manda lavar sua roupa enquanto vc esta no trampo. Legal.

    Responder
  3. sergio santos

    gostei cara, eu tenho uma eletrolux 6kg a mesma nao consegue juntar agua antes de chegar no nivel ela joga a agua toda fora me disseram q era a placa vc acha? aqui em maceio e 100.00reais abraco

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Sergio,
      desculpa a demora em lhe responder, mas como sempre comento, pode ser várias coisas este seu problema e não sou técnico de máquinas de lavar.
      Me parece falha no sensor de nível da água, ou a placa não está esperando a máquina encher. Mas só uma avaliação mais profunda para saber ao certo.

      Espero que já tenha resolvido seu problema. Abraços

      Responder
    2. Aldo

      Amigo não sei se ajuda, mas a minha tinha o mesmo problema, era uma peça mecânica que fica no painel, ela estava com uma mangueira desconectada.

      Responder
  4. ANSELMO LIMA

    MINHA MÁQUINA NÃO ENCHE DE ÁGUA. O RESTO DO PROCESSO ELA FAZ DI BOA, MAS, NA HORA DE ENCHER ELA ENCHE A CONTA GOTAS. TEM COMO RESOLVER ISSO?

    Responder
    1. Paulo Marcos Trentin Autor do post

      hehe, pois é Fernando, as vezes é muito louco pensar que pessoas que param para fazer alguma coisa, conseguem fazê-la mal feita.

      Neste caso da máquina, eu imagino que eles não tinham na época tecnologia que tornasse viável o relógio digital, por isso fizeram desta maneira mecânica e, digamos, trabalhosa.

      Responder
  5. Carlos Costa

    Muito legal cara o que tú fez, sua mãe deve ter ficado num orgulho só, na sua idade eu também adorava fazer projetos eletônicos com essas placas universais e matriz prontlabor.
    abraços.

    Responder
  6. José Roberto

    Cara quanta paciência você tem para fazer uma coisa dessa, Eu sou técnico de lavadoras e eletrônica, há mais de trinta anos,e já trabalhei em muitas autorizadas, e no começo consertei muito esses time (interruptor horário ), que você chama de relógio mecânico. Hoje e as vezes com muita insistência de algum cliente, pego esses time e dou para minha mulher consertar. O que você fez é inacreditável, você desmembrou a carta time do relógio mecânico. Se eu tivesse te conhecido antes te daria todo o esquema dessa maquina, e com a carta do time completa, Como ligar a entrada d,água, ligar o pressostato para fazer a agitação de 45 minutos, depois ligar a bomba para drenagem, centrifugar,depois encher novamente, agitar no enxague, centrifugar e desligar, etc.
    Confesso que já tentei montar uma placa, com os CI 4017(sequenciador )com triac, e funcionou bem, mais não consegui colocar o molho. Depois desistir, isso há 15 anos atras. no ano passado conheci o Arduíno, estudei um pouco, mais a minha cabeça já não dar mais. chego muito cansado da rua, e trago muitas placas eletrônica dos clientes para conserto. a maioria tem conserto, outras não. Hoje eu já precisaria de uma mine placa para substitui os time da brastemp clear antiga, muito querida pelos consumidores. Te faço uma proposta: quanto você cobraria para fazer um codigo fonte no atmega, só o codigo, pois eu faço esquema, placa de circuito impresso, etapa de potência, etc. Parabéns e que Deus sempre ilumine e te der mais e mais inteligencia.

    Tenho quase tudo de maquinas de lavar, se precisar de algum material, manuais, componentes de eletrônica etc. é só pedir… Abraço, Roberto Brastemp…

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi José Roberto.

      Obrigado pelas considerações, valeu pela força!
      Legal conhecer um pouco mais do que acontece no dia a dia, que bom que compartilhou sua experiência aqui.

      Sobre fazer o código fonte, estou um tanto ocupado ultimamente. Lhe faço uma contra-proposta: eu lhe ensino, na medida do possível, a fazer todo o código para suas máquinas, com Arduino. Assim você terá total autonomia para fazer seus consertos, que tal?

      Abraços!

      Responder
  7. Luciano

    ola segui suas recomendações para limpar as pontas dos contatos do relógio mecânico mas quando fui montar fiquei com duvida em que posição estava as engrenagens de plástico mas mesmo assim montei, porém o relógio esta girando muito rápido o que eu fiz de errado? Desde já te agradeço.

    ATT. Luciano

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Luciano,
      no geral não recomendo consertar estes timers. Eu fiz isso e sempre voltou a dar problema.

      Mas no seu caso, provavelmente a trava da engrenagem que o motor liga está faltando. Tem uma mola que, se não me engano, é responsável por isso.

      Responder
        1. Paulo Marcos Trentin Autor do post

          Então Luciano, se sua máquina tem o timer mecânico, e for igual a esta que apresento aqui, posso afirmar que é ele quem determina a velocidade entre cada ciclo. A execução do ciclo em si (bater para um lado e para outro por exemplo) é realizado pela placa da máquina.
          No caso deste timer, um pulso (um estralo do timer) durava dois minutos para rodar. Veja se o teu está demorando menos que isso e encontrará o problema.

          Responder
          1. Luciano

            Então Paulo, é sim igual o timer e a máquina que você apresenta. Não entendi, o que devo fazer? Desde já agradeço sua atenção.

            Att. Luciano

          2. Paulo Marcos Trentin Autor do post

            Então Luciano, ao ligar a máquina, veja quanto tempo seu timer demora para ir de um ponto a outro (um estalo). Deve ser 2 minutos (se for igual ao meu). Acredito que ele seja o problema.

  8. Patricia

    Olá Paulo

    Parabéns você é fera na coisa…..
    Cheguei aqui porque liguei minha maquina 110 no 220 e queria saber o que pode ter queimado antes de buscar a assistência. E aproveitando ela é um Brastemp lava e seca e faz tudo mas não esta centrifuga. Consegue me responder uma das duas perguntas

    Abraços

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Patricia,
      hehe eu me diverti com a máquina, mas não sou especialista em máquinas de lavar.

      Quando se liga em 220v qualquer dispositivo que era para funcionar em 110v, o que pode queimar são desde diodos, varistores, capacitores até trafos (em casos de fontes não chaveadas)

      Sobre sua máquina não centrifugar aí não sei, se for igual a máquina que apresento aqui, provavelmente estará com defeito no timer.

      Responder
  9. Vagner

    Olá,
    Estou com uma dificuldade e creio que vc pode me ajudar
    tenho uma lavadora Eletrolux Turbo 8k, as roupas estão ficando cheias de pelos e eu não encontro onde fica o filtro
    Vc saberia me dizer onde fica o filtro?
    Obrigado

    Responder
  10. André Andrade

    Olá Paulo, estou sem palavras para descrever o quão engenhoso vc foi para analisar, interpretar e projetar a solução deste problema, em tão pouco tempo, 7 dias. Parabéns pelo projeto. Eu gostei bastante das suas dicas!

    Sucesso pra vc!

    Um Abraço!

    Responder
  11. GersonJesus

    Parabéns pelo projeto. Isso pode ser aplicado nesses “tanquinhos” de valor baixo que não tem lógica de funcionamento? Um abraço e desejo muito sucesso pra ti.

    Responder
    1. Paulo Marcos Trentin Autor do post

      Obrigado Gerson!
      Sim, eu resolvi um problema bem específico, mas a ideia de controlar uma máquina à partir de uma lógica programada é bem genérica e pode ser aplicado em qualquer dispositivo. Basta fazer a o interfaceamento correto.

      Abraços

      Responder
  12. Alvaro

    Megaboga esse seu projeto!!!!
    Eu mexo muito pouco com arruino… Fiz alguns reles controlados pelo ethernet shield, e quando vi esse seu projeto na hora pensei… MÁQUINA LIGADA NA IBTERNET!!!! Imagina que top sua mãe deixar a roupa de molho por um tempo inderteminado, dar um comando a distância e a máquina lavar!!!! Ou então todo o feedback do LCD ser enviado por email ao telefone… Cara as possibilidades são muitas!!! E a internet das coisas viva o arduino!

    Responder
  13. Cleiton

    Parabéns por desenvolver essa Placa! Sou iniciante em Eletrônica e vai demorar entender o procedimento que você usou, mas com persistência tudo dá certo! Mais uma vez Parabéns pela inovação!

    Responder
  14. joaquim

    Amigo Paulo para jà antes de lhe fazer a pergunta deixe-me darlhe os parabens bem ca vai a minha màquina so despeja nem roda nem mete agua poderia me dar uma dica obrigado

    Responder
  15. Renato

    Boa tarde.
    Minha lavadora (BWL09B) não jogava a água fora e não centrifuga. Moro em uma região muito remota onde só existe um “técnico” em máquinas de lavar. Ele veio aqui e fez um teste na eletrobomba. Ela parece estar perfeita. Ele disse que o problema podia ser na placa de potência. Desmontei e constatei que ela tinha um “circuito queimado”. Meu pai estava vindo de Salvador e eu pedi que trouxesse a placa de potência para mim. Troquei.
    Quando fui fazer a primeira lavagem, ela funcionava normalmente até que avancei as etapas. Neste instante ela de um pequeno curto e deu um cheiro de queimado. Desliguei, desmontei e vi que a placa de potencia havia queimado no mesmo lugar. O mesmo circuito.
    Comprei uma placa de potência nova, mas estou com medo de queimá-la novamente. O único “técnico” da região não sabe o que é.
    Necessito de auxílio. Imagino que alguma peça deve estar em curto e queimando a placa de potência, mas eu não sei por onde começar.
    Abraço,
    Renato.

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Renato, boa noite.
      Que situação difícil a sua, mas tem solução!

      Sim, o que está acontecendo é que o circuito que aquela região da placa de potência liga está fazendo ela queimar. Você deve seguir a trilha queimada e chegar ao conector externo da placa de potência, por fim, seguir este fio e descobrir o que ele liga na máquina (motor, aquecedor etc). Este componente deve estar em curto e é ele o responsável.

      Você comentou que ela funcionou normalmente até avançar as etapas. Acredito que alguma coisa ela ainda não tinha feito, pois quando ela ia fazer esta coisa, é que queimou a placa. Tente descobrir o que ela ligou quando você avançou etapas que não estava ligado antes, talvez esteja aí seu problema.

      Se quiser me adicionar no gmail: paulopmt1@gmail.com podemos marcar para eu tentar te ajudar, pois sei como é triste não ter alguém por perto para resolver um problema desses.

      Abraços

      Responder
  16. Breno Borges

    Cara, parabéns pelo trabalho… Muito bakana vc compartilhar todo esse conhecimento de forma tão detalhada… Faço engenharia mecânica mas sempre me interessei por automação… conheci o arduino e resolvi pesquisar mais sobre o assunto e vi que vou ter muito estudo pela frente até compreender toda a lógica e conseguir explorar toda funcionalidade dessa plaquinha sinistra!… rsrs
    Usa e abusa dessa sua inteligência meu caro e continua compartilhando com a gente pra servir de inspiração!
    Abraço e tudo de bom!

    Responder
  17. Altair

    Olá Paulo, tudo bem?
    Cara, eu estava fazendo uma pesquisa para ver se conseguiria resolver um problema em minha máquina quando vi sua postagem. Sabe o que eu fiz? Dei muita risada amigo!
    Fico maravilhado quando vejo o dom que Deus desperta nas pessoas. Parabéns amigo, que Deus continue te abençoando, te protejendo e te iluminando sempre.

    Responder
  18. Murario Filho

    Genial. Parabéns pelo projeto!
    Sou fascinado por eletrônica, mas confesso que estou bem longe de tamanha proeza!
    Um grande abraço, grande GÊNIO!

    Responder
  19. Jose Silva

    Parabéns pelo projecto e por partilhar.
    Eu também sou assim um bocado curioso como você, e a razão porque vim ter ao seu blog é exactamente por andar com a mesma ideia de substituir uma placa da minha máquina tal como você fez. Mas eu queria usar um PIC . Não sei se vai dar certo. E como a máquina tem várias velocidades de centrifugação, torna-se ainda mais difícil. Para ficar a centrifugar com a velocidade máxima, se calhar, no inicio da centrifugação começa a dar muitos saltos. Penso que teria de usar PWM na programação e ainda não sei muito bem como isso se faz.
    Se me puder dar alguma dica, agradeço.
    Obrigado por tudo.

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Jose, que bom que é curioso, isso é ótimo para se aprender coisas novas!
      Por que não usar Arduino? Com ele você faz pwm assim: analogWrite(pino_saida, valor_pwm); Simples assim!

      acho legal estudar PIC e qualquer outro microcontrolador, mas se você quer facilitar sua vida e produzir bastante vai de Arduino, depois tu se aprofunda no pic, que tal?

      Responder
  20. Jose Silva

    Obrigado Paulo pela sua resposta.
    Neste momento estou mais virado para os PICs. Já dei uma vista de olhos no Arduino e vou aprofundar mais um pouco.

    Responder
  21. Mônica Soares

    Gostei muito de tudo que você escreveu e ia comentários te parabenizando, te parabenizou também por ser tão inteligente e dedicado, mas i que me trouxe até aqui foi que a minha máquina lava e seca da Eletrolux, depois de uma lavagem, fui colocar outras roupas para a próxima lavagem não consegui liga-la nem sinal de nada, verifiquei a tomada parecia que estava sem energia, mas a luz da casa funcionava e fiz um teste com o carregador do celular estava funcionando. Ela já saiu da garantia e a visita do técnico e caríssimo pelo fato de ser longe , estou disposta a tentar arruma -la. Por favor me ajude !!!

    Responder
    1. Paulo Marcos Trentin Autor do post

      Olá Mônica, obrigado pelas considerações.
      Infelizmente é bastante difícil lhe ajudar remotamente. Qualquer tipo de teste que eu pediria para você fazer, estaria lhe colocando em risco, afinal não sei qual é seu ambiente, ferramentas que possui e sua experiência.

      Admiro sua vontade em querer resolver o problema, porém por motivos de segurança e como não sou técnico de máquinas, não poderei lhe ajudar. Apesar de ser caro, recomendo que você contrate um profissional e fique em cima dele, olhando os testes que vai fazer e questionando tudo. É um bom jeito de começar a aprender!

      Responder
    2. Junior Braga

      Bom dia Mônica!
      Vi o comentário do Marcos, e realmente ele tem razão. Devemos procurar um profissional da área para não ser mais prejudicial as consequências. Porem, como eu sou curioso, e tenho algumas ferramentas, vou lhe contar a minha experiência. Tenho uma Electrolux igualzinha a do Marcos. A minha esposa certo dia foi ligar, e a mesma não deu sinal algum, bem parecido a sua. Dai eu tive a curiosidade em abri-la. Minha prezada, para minha surpresa quando abrir o painel dela, os catitas haviam ruido a parte inferior do painel, entrado na fiação elétrica e cortado, picado todos os fios do painel. Eu procurei uma autorizada, comprei o chicote completo do painel e substituí tomando cuidado com as cores e encaixe, e quando liguei a máquina foi um sucesso. Graças Deus já tem quase um ano e está ótima! Há! Comprei também uma ratoeira. rsrssss. Espero que seu problema seja resolvido fácil igual ao meu. Boa sorte!

      Responder
  22. Lucimar

    Paulo, sua mãe deve ser uma mulher muito orgulhosa do filho que tem, primeiro pela sua inteligência; segundo, pelo exemplo de humildade em dividir seus prodígios com os outros. Este é o lado bom da internet e das redes sociais: sempre encontramos gente bem intencionada como você, fazendo do mundo um lugar melhor pra se viver. Lendo os diversos comentários, dá pra ter uma ideia da quantidade enorme de pessoas que você ajuda com sua atitude. Parabéns, cara! Deus te abençoe sempre!

    Responder
  23. Alexandre Alves

    ola,Paulo Trentin sou de Videira SC também,quero parabenizar pelo projeto também estou com o mesmo problema você não tem uma placa dessas para venda.

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Alexandre, infelizmente não tenho nenhuma placa igual pra vender. Mas se tiver interesse em desenvolver uma posso lhe ajudar na medida do possível. O codigo fonte está todo no site, e o esquema elétrico é relativamente simples.

      Responder
  24. Marcio

    Parabéns pelo projeto!! mto bom mesmo!
    estou tentando fazer o mesmo!hehehe
    mas num tenho pratica nenhuma com arduino.
    vc teria idéia de como fazer a agitação da maquina diretamente no arduino?

    Responder
    1. Paulo Marcos Trentin Autor do post

      Oi Marcio, obrigado pelas considerações!

      que legal que está tentando fazer o mesmo hehe, divertido isso.
      A agitação depende de atuar diretamente nos motores com triacs de alta potência, como um BTA16-600 por exemplo. Mas tudo depende do motor que a máquina usa.

      É um processo trabalhoso, chavear a lógica do relógio como fiz, simplifica um pouco o processo.

      Bons estudos!

      Responder

Deixe uma resposta

O seu endereço de email não será publicado Campos obrigatórios são marcados *

Você pode usar estas tags e atributos de HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>