Agitador magnético com controle de velocidade com Arduino

Olá pessoal,

No post anterior fizemos um agitador magnético caseiro utilizando um potênciômetro para controlar a velocidade do agitador e está funcionando muito bem. Neste post faremos um controle de velocidade através de dois botões: um para aumentar a velocidade e outro para diminuir a velocidade em até 10 velocidades diferentes e um display OLED que vai informar a velocidade do agitador.

Componentes utilizados:

- 1 TIP122
- 1 Display OLED 0.96" I2C
- 2 push-button
- 1 Diodo 1N4001

O funcionamento do circuito é simples: escreve-se na saída PWM da porta digital 9 um determinado valor e nessa saída está ligado à base do TIP 122, esse transistor de potência está no circuito para controlar a corrente que é mais alta no motor, a partir de uma corrente baixa proporcionada pela saída PWM do Arduino, funcionando como um amplificador.

 Usa-se o TIPpois o motor requer uma corrente mais alta que a disponível no Arduino, e alimentá-lo diretamente com o microcontrolador danifica o último, portanto sua alimentação é feita por uma fonte de 12V. O diodo 1N4001 foi colocado como uma proteção para a contra-corrente que o motor pode induzir.

Pressionando-se os botões para aumentar ou diminuir a velocidade altera-se o valor de escrita na porta 9. Quanto mais alto o valor de escrita maior a velocidade.

Note que os terras da fonte e do Arduino estão interligados.

 

Segue o código utilizado:

#include "U8glib.h"
#include <stdlib.h>


int btnMais = 4;
int btnMenos = 3;
int velocidade = 0;
int intervalo = 22;
int rotacaomin = 57;
int rotacaomax = 255;
int rotacaoatual;
int btnMaisState;
int btnMenosState;
char tempvelocidade[2];

U8GLIB_SSD1306_128X64 u8g(U8G_I2C_OPT_NO_ACK);  // Display which does not send AC



void setup() {
 
      pinMode(9,OUTPUT);
      pinMode(btnMais,INPUT);
      pinMode(btnMenos,INPUT);
      Serial.begin(9600);
      if ( u8g.getMode() == U8G_MODE_R3G3B2 ) {
          u8g.setColorIndex(255);     // white
      }
      else if ( u8g.getMode() == U8G_MODE_GRAY2BIT ) {
          u8g.setColorIndex(3);         // max intensity
      }
      else if ( u8g.getMode() == U8G_MODE_BW ) {
          u8g.setColorIndex(1);         // pixel on
      }
      else if ( u8g.getMode() == U8G_MODE_HICOLOR ) {
          u8g.setHiColorByRGB(255,255,255);
  }
 }


void loop() {
    btnMaisState = digitalRead(btnMais);
    btnMenosState = digitalRead(btnMenos);
   
    if ((velocidade >=0 ) && (velocidade <= 10)) {
      if ((btnMaisState == HIGH) && (velocidade < 10)) {
         velocidade = velocidade + 1;
      }
   
      if ((btnMenosState == HIGH) && (velocidade > 0)) {
         velocidade = velocidade - 1;
      } 
     
      switch (velocidade) {
        case 0:
            //Para o ventilador
            analogWrite(9,0);
            rotacaoatual = 0;
            break;
        case 1:
            analogWrite(9,rotacaomin);
            rotacaoatual = rotacaomin;
            break;
        case 2:
            analogWrite(9,rotacaomin+(1*intervalo));
            rotacaoatual = rotacaomin+(1*intervalo);
            break;
        case 3:
            analogWrite(9,rotacaomin+(2*intervalo));
            rotacaoatual = rotacaomin+(2*intervalo);
            break;
        case 4:
            analogWrite(9,rotacaomin+(3*intervalo));
            rotacaoatual = rotacaomin+(3*intervalo);
            break;
        case 5:
            analogWrite(9,rotacaomin+(4*intervalo));
            rotacaoatual = rotacaomin+(4*intervalo);
            break;
        case 6:
            analogWrite(9,rotacaomin+(5*intervalo));
            rotacaoatual = rotacaomin+(5*intervalo);
            break;
        case 7:
            analogWrite(9,rotacaomin+(6*intervalo));
            rotacaoatual = rotacaomin+(6*intervalo);
            break;
        case 8:
            analogWrite(9,rotacaomin+(7*intervalo));
            rotacaoatual = rotacaomin+(7*intervalo);
            break;
        case 9:
            analogWrite(9,rotacaomax+(8*intervalo));
            rotacaoatual = rotacaomin+(8*intervalo);
            break;
        case 10:
            analogWrite(9,rotacaomax+(9*intervalo));
            rotacaoatual = rotacaomin+(9*intervalo);
            break;
   
       }  
    }
    itoa(velocidade,tempvelocidade,10);
    u8g.firstPage(); 
    do
    {
          //Comandos graficos para o display devem ser colocados aqui
          //Seleciona a fonte de texto
          u8g.setFont(u8g_font_8x13B);
          u8g.drawStr( 24, 15, "VELOCIDADE");
          u8g.setFont(u8g_font_fub30);
          if (velocidade == 10) {
              u8g.drawStr(41,57,tempvelocidade);
          }
          else
          { 
          u8g.drawStr(50,57,tempvelocidade);
          }
          u8g.drawRFrame(0, 18, 128, 46, 4);


    } while( u8g.nextPage() );
  
    delay(500);
 
}

Segue abaixo vídeo mostrando o funcionamento:

 Pessoal, é isso aí! Quaisquer dúvidas entrem em contato!

Novo projeto: agitador magnético com controle de velocidade

Olá pessoal!

Neste post vamos iniciar um novo projeto que consiste de um agitador magnético caseiro, feito de materiais facilmente encontrados como sucatas eletrônicas e que, no final de contas, possibilitam a implementação com baixo custo. Primeiramente vamos implementar sem nenhum tipo de controle com Arduino, usando somente um potenciômetro para controlar a velocidade de um ventilador. Vamos lá!

Os materiais que utilizei foram estes:

1)  Quadro Tigre para acomodar o cooler.

2) Cooler de PC 12V: o cooler foi retirado de uma fonte de computador e fixado na tampa do quadro Tigre.

3) Imã de neodímio: nesta mesma tampa do outro lado ficará uma abertura onde serão fixados os dois imãs. Foi utilizada cola quente.

4) Potenciômetro de 5K: é feita uma pequena abertura com uma furadeira para acomodar o potenciômetro na lateral da caixa:

5) Protoboard pequena: vide imagem acima.


6) Fonte de 12V 1A: é feita uma pequena abertura na lateral da caixa para a passagem do cabo da fonte de 12V. Coloquei dois conectores de protoboard nos dois fios da fonte.

 
7) Capa de CD (acrílico): pegar uma capa de CD em acrílico e desmontar. pegar a parte com parte lisa e colar com cola quente na caixa para que fique logo acima dos imãs sem tocá-los.

Ficará assim:

7) Peixinho para agitador magnético: o peixinho é um imã ou mesmo um pedaço de metal que fará o movimento no líquido. Você pode comprar o peixinho ou fazer o peixinho utilizando a parte plástica da caneta esferográfica (tira a carga da caneta e corta-se o tubo plástico do tamanho que se quer o peixinho) e duas  tampas de tubo da esferográfica (outra extremidade da caneta). Basta inserir um parafuso, pedaço de arame grosso ou mesmo um outro imã bem pequeno no tubo cortado e fechar com duas tampas de tubo (não é a tampa da caneta mas sim a do tubo, conforme imagem abaixo).

Peixinho magnético

A montagem interna ficou assim:

E o resultado final depois de fechada a tampa:

O vídeo final mostrando o funcionamento:

No próximo post colocaremos um Arduino para controlar a velocidade através de dois botões. Teremos 10 velocidades diferentes e poderemos aumentar ou diminuir a velocidade usando esses dois botões.