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.

Tape changer - códigos de implementação dos comandos do trocador de fitas

Olá pessoal,

Neste post veremos a implementação dos comandos do trocador de fitas. Através de comandos recebidos pela serial o Arduino aciona os motores e o servo para fazer os movimentos.

// Programa : Tape changer - garra e motores de passo
// Autor : Fernando Asashi Nitatori 
#include <Servo.h>  // Biblioteca para acionamento do servo
#include <AccelStepper.h> //Biblioteca para os motores de passo

Servo myservo;  // Cria um objeto do tipo Servo para controlar um servo chamado myservo

int pos = 0;    // variavel para armazenar a posicao do servo
int position;
int positioncenter = 84; // variavel para setar a posicao central do servo

int velocidade_motor_1 = 600; //velocidade do motor de passo 1
int velocidade_motor_2 = 600; //velocidade do motor de passo 1
int aceleracao_motor_1 = 80; //aceleracao do motor de passo 1
int aceleracao_motor_2 = 80; //aceleracao do motor de passo 1
int sentido_horario_motor_1 = 0;
int sentido_antihorario_motor_1 = 0;
int sentido_horario_motor_2 = 0;
int sentido_antihorario_motor_2 = 0;
int chave1;
int chave2;
int chave3;
int pino_endstop1 = 9;
int pino_endstop2 = 10;
int pino_endstop3 = 11;
int posicao = 0;
int posicao2 = 0;
int posicao1_motor1 = 8000;
int posicao2_motor1 = 16000;
int posicao3_motor1 = 24000;
int posicao1_motor2 = 2500;
int posicao2_motor2 = 10000;
int posicao3_motor2 = 22000;

char ultcmdservo = 'm';

char comando;

// Definicao pino ENABLE
int pino_enable = 8;

// Definicao pinos STEP e DIR
AccelStepper motor1(1,2,5);
AccelStepper motor2(1,4,7);


void setup() 
{
  Serial.begin(9600);
  pinMode(pino_enable, OUTPUT);

  pinMode(pino_endstop1, INPUT);
  pinMode(pino_endstop2, INPUT);
  pinMode(pino_endstop3, INPUT);
  digitalWrite(pino_endstop1, HIGH);
  digitalWrite(pino_endstop2, HIGH);
  digitalWrite(pino_endstop3, HIGH);

  // Configuracoes iniciais motor de passo
  motor1.setEnablePin(pino_enable);
  motor1.setMaxSpeed(velocidade_motor_1);
  motor1.setSpeed(velocidade_motor_1);
  motor1.setAcceleration(aceleracao_motor_1);
 
  // Configuracoes iniciais motor de passo
  motor2.setEnablePin(pino_enable);
  motor2.setMaxSpeed(velocidade_motor_2);
  motor2.setSpeed(velocidade_motor_2);
  motor2.setAcceleration(aceleracao_motor_2);

  sentido_horario_motor_1 = 0;
  sentido_antihorario_motor_1 = 0;
  sentido_horario_motor_2 = 0;
  sentido_antihorario_motor_2 = 0;
 
 
  ligaservo();
  myservo.write(positioncenter);
  Serial.println("Digite l, m ou r para movimentar o servo e clique em ENVIAR...");
  Serial.println("Digite c para parar o motor 1...");
  Serial.println("Digite f para parar o motor 2...");

  Serial.println("Digite 0 para girar o motor 1 para esquerda.");
  Serial.println("Digite 1 para girar o motor 1 para a posicao 1.");
  Serial.println("Digite 2 para girar o motor 1 para a posicao 2.");

  Serial.println("Digite 3 para girar o motor 1 para a posicao 3.");
  Serial.println("Digite 5 para girar o motor 2 para esquerda.");

  Serial.println("Digite 6 para girar o motor 2 para a posicao 6.");
  Serial.println("Digite 7 para girar o motor 2 para a posicao 7.");
 
  //Serial.println("Digite 8 para girar o motor 2 para a posicao 8.");

}

void ligaservo() {
     myservo.attach(19,500,2700);  // attaches the servo on pin 19 to the servo object
}

void desligaservo() {
     myservo.detach();  //desliga o servo
}

/*
void movezero() {
      posicao = 0;
      moveposicao0motor1();
}
*/
void moveposicao0motor1() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_1 = 0;
       sentido_antihorario_motor_1 = 1;
}

void moveposicao0motor2() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_2 = 1;
       sentido_antihorario_motor_2 = 0;
}

void moveposicao1motor2() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_2 = 0;
       sentido_antihorario_motor_2 = 1;
       posicao2 = 1;
}

void moveposicao2motor2() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_2 = 0;
       sentido_antihorario_motor_2 = 1;
       posicao2 = 2;
}

void moveposicao3motor2() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_2 = 0;
       sentido_antihorario_motor_2 = 1;
       posicao2 = 3;
}

void moveposicao1motor1() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_1 = 1;
       sentido_antihorario_motor_1 = 0;
       posicao = 1;
}

void moveposicao2motor1() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_1 = 1;
       sentido_antihorario_motor_1 = 0;
       posicao = 2;
}

void moveposicao3motor1() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_1 = 1;
       sentido_antihorario_motor_1 = 0;
       posicao = 3;
}

void ligamotor1horario() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_1 = 1;
       sentido_antihorario_motor_1 = 0;

}

void ligamotor1antihorario() {
        digitalWrite(pino_enable, LOW);
        sentido_horario_motor_1 = 0;
        sentido_antihorario_motor_1 = 1;

}

void ligamotor2horario () {
        digitalWrite(pino_enable, LOW);
        sentido_horario_motor_2 = 1;
        sentido_antihorario_motor_2 = 0;
       
}

void ligamotor2antihorario() {
        digitalWrite(pino_enable, LOW);
        sentido_horario_motor_2 = 0;
        sentido_antihorario_motor_2 = 1;
  //      puxa_horario_motor_2 = 0;
  //      puxa_antihorario_motor_2 = 0;
      

}



void loop()
{
 
  // Aguarda os caracteres na serial
  if (Serial.available() > 0)
  {
      comando = (char) Serial.read();
   
      if (comando == 'c')
      {
        Serial.println("Letra c recebido - Parando motor 1...");
        sentido_horario_motor_1 = 0;
        sentido_antihorario_motor_1 = 0;
        motor1.stop();
        motor1.runToPosition();
        motor1.setCurrentPosition(0);
        digitalWrite(pino_enable, HIGH);
      }
     
      if (comando == 'f')
      {
        Serial.println("Letra f recebido - Parando motor 2...");
        sentido_horario_motor_2 = 0;
        sentido_antihorario_motor_2 = 0;
        motor2.stop();
        motor2.runToPosition();
        motor2.setCurrentPosition(0);
        digitalWrite(pino_enable, HIGH);
      }
     
      if (comando == 'l') {
         ligaservo();
         if (ultcmdservo == 'r') {
             Serial.println("Nao digitar comando r aqui. Va para o centro com m e depois va para direita com r");
         }
         else
         {
             for(pos = positioncenter; pos<=162; pos += 1) 
             {               
                    myservo.write(pos);              // tell servo to go to position in variable 'pos'
                    delay(50);
             }
         }
         ultcmdservo = 'l';
         desligaservo();
      }

      if (comando == 'm') {
           ligaservo();
           position = myservo.read();
           //Serial.println(position);
           if (position >= positioncenter) {
               for(pos = position; pos>=positioncenter; pos -= 1)  // goes from 0 degrees to 180 degrees
                {
                        myservo.write(pos);              // tell servo to go to position in variable 'pos'
                        delay(50);                       // waits 15ms for the servo to reach the position
                }
                 
           }        
           else
           {
              for(pos = position; pos<=positioncenter; pos += 1)  // goes from 0 degrees to 180 degrees
               {                                  // in steps of 1 degree
               
                      myservo.write(pos);              // tell servo to go to position in variable 'pos'
                      delay(50);                       // waits 15ms for the servo to reach the position
               }
           }
           ultcmdservo = 'm';
           desligaservo();
      }
 
      if (comando == 'r') {
         ligaservo();
         if (ultcmdservo == 'l') {
             Serial.println("Nao digitar comando l aqui. Va para o centro com m e depois va para direita com l");
         }
         else
         {
             for(pos = positioncenter; pos>=5; pos-=1)  { 
                  myservo.write(pos);              // movimenta o servo ate a posicao 
                  delay(50);                       // espera 50ms para o servo atingir a posicao
              }
         }
         ultcmdservo = 'r';
         desligaservo();   
      }    
     
      if (comando == '0') {
          moveposicao0motor1();
      }

     
      if (comando == '1') {
          moveposicao1motor1();
      }

      if (comando == '2') {
          moveposicao2motor1();
      }

      if (comando == '3') {
          moveposicao3motor1();
      }

      if (comando == '5') {
          moveposicao0motor2();
      }
     
      if (comando == '6') {
          moveposicao1motor2();
      }
     
      if (comando == '7') {
          moveposicao2motor2();
      }
     
      if (comando == '8') {
          moveposicao3motor2();
      }
  }

  chave1 = digitalRead(pino_endstop1);
  chave2 = digitalRead(pino_endstop2);
  chave3 = digitalRead(pino_endstop3);
      
  // Move o motor1 no sentido horario ate a posicao desejada
  if (sentido_horario_motor_1 == 1){
          if (posicao == 1) {
              motor1.moveTo(posicao1_motor1);
              motor1.run();
          }
          if (posicao == 2) {
              motor1.moveTo(posicao2_motor1);
              motor1.run();
          }
          if (posicao == 3) {
              motor1.moveTo(posicao3_motor1);
              motor1.run();
          }
         
  }
 
  // Move o motor1 no sentido anti-horario ate a posicao desejada
  if (sentido_antihorario_motor_1 == 1){
        if (posicao == 0) {// se posicao for 0 move ate encontrar chave fim de curso
           if (chave1 == 0) {
              Serial.println("Fim de curso - Parando motor 1...");
              sentido_horario_motor_1 = 0;
              sentido_antihorario_motor_1 = 0;
              motor1.stop();
              motor1.runToPosition();
//              motor1.setCurrentPosition(0);
              digitalWrite(pino_enable, HIGH);
            }
            else
            {
                motor1.move(-20000);
                motor1.run();
            }
       }
           motor1.moveTo(0);
           motor1.run();
  }
 
 
  // Move o motor2 no sentido horario ate a posicao desejada
  if (sentido_horario_motor_2 == 1){
      if (posicao2 == 0) {
          if (chave2 == 0) {
            Serial.println("Fim de curso 2 - Parando motor 2...");
            sentido_horario_motor_2 = 0;
            sentido_antihorario_motor_2 = 0;
            motor2.stop();
            motor2.runToPosition();
            digitalWrite(pino_enable, HIGH);
          }
          else
          {
          motor2.move(-19000);
          motor2.run();
          }
      }

          motor2.moveTo(0);
          motor2.run();

  }
 
  // Move o motor2 no sentido anti-horario ate a posicao desejada
  if (sentido_antihorario_motor_2 == 1) {
       if (posicao2 == 1) {
              motor2.moveTo(posicao1_motor2);
              motor2.run();
          }
      
       if (posicao2 == 2) {
              motor2.moveTo(posicao2_motor2);
              motor2.run();
          }
      
       if (posicao2 == 3) {
              motor2.moveTo(posicao3_motor2);
              motor2.run();
          }
   } 

}




O código acima  é para a implementação do movimento da garra e servo. Segue abaixo código para o motor DC:

 //Programa: Tape changer - abre e fecha a garra

#include <AFMotor.h>

AF_DCMotor motor(1);

char comando;

void abregarra() {
            uint8_t i;
            motor.run(BACKWARD);

            for (i=0; i<128; i++) {
                motor.setSpeed(i);
                delay(10);
            }
            delay(3000);
            motor.run(RELEASE);
}

void fechagarra() {
            uint8_t i;
          
            motor.run(FORWARD);
 
            for (i=0; i<255; i++) {
                motor.setSpeed(i);
                delay(10);
             }

             delay(2000);  
 
}

void setup () {
      Serial.begin(9600);
 
}

void loop () {
      if (Serial.available() > 0)
      {
          comando = (char) Serial.read();
          
          if (comando == 'g')
          {
              Serial.println("Abrindo garra");
              abregarra();
          }
     
          if (comando == 'h')
          {
              Serial.println("Fechando garra");
              fechagarra();
          }
      }
}
 O script retirafita.sh é um script que roda em shell Linux ou FreeBSD. Segue abaixo script completo com os comandos para retirar a fita do drive e colocá-la no compartimento:

#Script retira.sh
echo "Abre a garra..."
echo 'g' > /dev/tty.usbmodem1421
sleep 5s
echo "Fecha a garra..."
echo 'h' > /dev/tty.usbmodem1421
sleep 5s
echo "Movimenta a garra ate a posicao 8..."
echo '8' > /dev/tty.usbmodem1411
sleep 45s
echo "Vira para a direita..."
echo 'r' > /dev/tty.usbmodem1411
sleep 5s
echo "Movimenta a garra ate a posicao 5..."
echo '5' > /dev/tty.usbmodem1411
sleep 45s
echo "Abre a garra..."
echo 'g' > /dev/tty.usbmodem1421
sleep 5s
echo "Movimenta a garra ate a posicao 7..."
echo '7' > /dev/tty.usbmodem1411
sleep 22s
echo "Fecha a garra..."
echo 'h' > /dev/tty.usbmodem1421
sleep 5s
echo "Movimenta a garra ate a posicao 5..."
echo '5' > /dev/tty.usbmodem1411
sleep 27s
echo "Movimenta a garra ate a posicao 6..."
echo '6' > /dev/tty.usbmodem1411
sleep 10s
echo "Vai para o centro..."
echo 'm' > /dev/tty.usbmodem1411
sleep 5s
echo "Abre a garra..."
echo 'g' > /dev/tty.usbmodem1421
sleep 5s
echo "Movimenta a garra ate a posicao 5..."
echo '5' > /dev/tty.usbmodem1411
sleep 5s

Quaisquer dúvidas sobre os códigos entrem em contato,

Até mais pessoal,

Tape changer - acionamento do motor de passo com CNC shield

Olá pessoal,

Dando continuidade ao detalhamento do projeto de tape changer vamos mostrar como se dá o acionamento do motor de passo NEMA 17 na mesa linear. Afinal de contas, como ligar um motor de passo?
Segue vídeo explicativo da ligação com CNC shield e o acionamento:

Uma das coisas que já podemos concluir é que este motor de passo exigindo pelo menos 12V de tensão e fornecer uma corrente de até 1A (está nas especificações do motor) é necessário um circuito extra que permita o Arduino interagir nestes patamares de tensão e corrente. Aí que entram em ação os drivers que terão como função acionar as bobinas do motor através de transistores de potência e ficando o Arduino somente com a função de controlar o acionamento. O driver que utilizaremos é o A4988. Segue abaixo o esquema de ligação se for usar protoboard:

Há uma outra maneira de se ligar esse motor de passo utilizando o CNC Shield.

Note que o driver A4988 é encaixado em dos compartimentos do shield CNC para cada motor/eixo:

Segue abaixo a pinagem utilizada pelo shield:

Para testar o motor de passo implementamos o seguinte código abaixo:

Créditos: Blog Arduino e Cia:
Link: http://www.arduinoecia.com.br/2015/03/controle-motor-de-passo-bipolar-driver-A4988.html

// Programa : Driver motor de passo A4988
// Autor : Arduino e Cia

#include <AccelStepper.h>

int velocidade_motor_1 = 700;
int aceleracao_motor_1 = 80;
int sentido_horario_motor_1 = 0;
int sentido_antihorario_motor_1 = 0;


char comando;

// Definicao pino ENABLE
int pino_enable = 8;

// Definicao pinos STEP e DIR
AccelStepper motor1(1,2,5);


void setup() 
{
  Serial.begin(9600);
  pinMode(pino_enable, OUTPUT);


  // Configuracoes iniciais motor de passo
  motor1.setEnablePin(pino_enable);
  motor1.setMaxSpeed(velocidade_motor_1);
  motor1.setSpeed(velocidade_motor_1);
  motor1.setAcceleration(aceleracao_motor_1);
 
  sentido_horario_motor_1 = 0;
  sentido_antihorario_motor_1 = 0;
 
  Serial.println("Digite a, b ou c e clique em ENVIAR...");
}

void ligamotor1horario() {
       digitalWrite(pino_enable, LOW);
       sentido_horario_motor_1 = 1;
       sentido_antihorario_motor_1 = 0;
 
}

void ligamotor1antihorario() {
        digitalWrite(pino_enable, LOW);
        sentido_horario_motor_1 = 0;
        sentido_antihorario_motor_1 = 1;
 
}


void loop()
{

  // Aguarda os caracteres no serial monitor
  if (Serial.available() > 0)
  {
      comando = (char) Serial.read();
   
      if (comando == 'a')
      {
        Serial.println("Letra a recebido - Girando motor1 sentido horario ate chave2 acionar.");
        ligamotor1horario();
      }
     
      if (comando == 'b')
      {
        Serial.println("Letra b recebido - Girando motor1 sentido anti-horario ate chave1 acionar.");
        ligamotor1antihorario();
      }
    
      if (comando == 'c')
      {
        Serial.println("Letra c recebido - Parando motor...");
        sentido_horario_motor_1 = 0;
        sentido_antihorario_motor_1 = 0;
        motor1.moveTo(0);
        digitalWrite(pino_enable, HIGH);
      }
     
  
  }
    
 
  if (sentido_horario_motor_1 == 1)
  {
        motor1.moveTo(20000);
        motor1.run();
  } 
 
 
  if (sentido_antihorario_motor_1 == 1)
  {
          motor1.moveTo(-20000);
          motor1.run();
  } 
} 


É isso aí pessoal! Espero que tenham gostado! Até a próxima!

Tape changer - motor de passo, acoplamento e fuso

Olá pessoal,

Neste post vou detalhar como implementei o movimento retilíneo da garra usando motor de passo, acoplamento e fuso com barra roscada.
Detalhes de como implementei no vídeo abaixo:

Usei os seguintes componentes:

1) Motor de passo Nema 17 (descrito no post anterior).
2) Barra roscada 8mm:

Barra roscada de 8mm

3) Acoplamento flexível 5mm x 8mm:

4) Porca sextavada 8mm:

5) Corrediça telescópica:

6) Chapas em MDF:

 É isso aí pessoal!

Até a próxima!

Tape changer - mudança no projeto

Bom dia pessoal,

Vamos lá para mais um post sobre e o projeto do tape changer e no último post descrevi as dificuldades de se implementar um braço robótico. Neste post vou descrever a mudança radical que tive de implementar para resolver as dificuldades. Vamos lá:

1) Mudança: utilização de motores de passo ao invés de servos para movimentação retilínea da garra.

Uma decisão que tive tomar  foi a de utilizar motor de passo ao invés de servos. Agora qual motor de passo utilizar? Em um primeiro momento resolvi começar a fazer testes com motores de passo para drives de CD/DVD.

Pensei: "Poxa que legal... funciona...e com Arduino ainda". Uma dificuldade que encontrei para utilizar estes motores de passo foi a dificuldade de implementar um fuso mais comprido a ponto de conseguir mover a fita ou colocá-la no drive LTO. Também pensei em utilizar dois motores de passo e dois fusos para fazer a abertura e fechamento da garra porém sem sucesso.
De repente tive um insight: esse movimento retilíneo está bastante presente em projetos de CNC!!! Comecei a pesquisar as implementações de fusos e motores de passo para movimentar em eixos nos projetos de CNC e encontrei um canal excelente no Youtube - o canal Eletrônica Hoje:

Agradeço a ajuda!!!


2) Implementação do movimento retilíneo:

Usei como base este vídeo:

O motor de passo que escolhi foi esse:

Motor de passo Nema 17

Para acionamento e controle do motor de passo escolhi o driver A4988:

Driver A4988

Segue abaixo esquema de ligação do driver ao motor de passo:

Atente para o esquema onde é realizada a ligação de alimentação externa (pinos VMOT e GND) que exige a conexão de um capacitor de 100 microFarad para dar maior estabilidade no fornecimento de tensão. Os enrolamentos do motor de passo devem ser ligados nos pinos 2B,2A,1A e 1B.
Maiores detalhes de ligação estão em alguns vídeos do canal Eletrônica Hoje:

a) Ligação dos motores de passo de 4 ou 6 fios:

b) Ajuste de corrente dos drivers A4988 - Parte 1:

c) Ajuste de corrente dos drivers A4988 - Parte 2:

A ligação com o Arduino e o código para testes são estes:

http://www.arduinoecia.com.br/2015/03/controle-motor-de-passo-bipolar-driver-A4988.html


É importante fazermos um teste do motor de passo sem carga para verificar o comportamento do motor para depois fazermos a conexão do fuso.

No próximo post vamos ver como fazer o acoplamento do motor de passo ao fuso que transmitirá o movimento para o conjunto a ser movimentado.

Até mais!

Agradecimentos ao Canal Eletrônica Hoje e ao site Arduino e Cia.

Tape changer com braço robótico - parte 2

Olá pessoal! Neste post vou contar para vocês um pouco da experiência que tive para implementar o projeto de tape changer (trocador de fita) utilizando braço robótico. Bom, vamos lá!
Como não tenho noção nenhuma a ponto de construir a estrutura do braço robótico resolvi comprar uma em alumínio...
Comprei este no Aliexpress:

Não veio com instruções de montagem porém o vendedor me enviou por e-mail as instruções (em chinês) mas muito bem detalhado e não foi difícil a montagem.

Depois de montado comprei os servos (6 servos) MG995 e os montei na estrutura. A partir daí fomos aos testes.

Realizadas as ligações dos servos atentamos para a corrente exigida pelos servos e tensão de alimentação e precisamos de alimentação externa. Deve-se prestar atenção na interligação do terra do Arduino com o terra da alimentação externa dos servos.
Fizemos o controle da movimentação dos servos através de potenciômetros e notamos que determinados servos eram mais exigidos que outros em termos de corrente e também que o movimento necessário do braço e da garra para remover a fita ou colocar tem que ser retilíneo (por conta da fita), o que dificultou bastante o teste pois teríamos que acionar vários servos ao mesmo tempo para reproduzir este movimento retilíneo. Somada a esta dificuldade temos também tivemos que recorrer a uma fonte de alimentação com maior capacidade de fornecimento de corrente.

Devido às dificuldades de implementação chegamos a conclusão que era necessário rever o projeto e pensar na possibilidade de se usar motores de passo para realizar o movimento retilíneo da garra. É que fizemos e veremos no próximo post como foi essa mudança na implementação.

Até a próxima!