Medidor de pH - conexão dos componentes e detalhes de implementação

pH significa “potencial hidrogeniônico”, uma escala utilizada para medir acidez, neutralidade ou alcalinidade de uma determinada solução. Tamanha é sua importância, que a determinação do pH é realizada em laboratórios de controle de qualidade em diversas indústrias, como a indústria química, de alimentos, bebidas, de cosméticos, farmacêutica, análises clínicas e até no controle da preservação do meio ambiente.

Neste post veremos um novo projeto desenvolvido no meu local de trabalho (campus da UNESP Sorocaba - Instituto de Ciências e Tecnologia de Sorocaba) para atender uma demanda de construção de um medidor de pH utilizando Arduino, com base neste projeto:

https://pubs.acs.org/doi/abs/10.1021/acs.jchemed.7b00479

Fizemos adaptações no projeto para utilizar o módulo de leitura pH PH-4502C e o eletrodo que vem junto com ele :

https://www.usinainfo.com.br/outros-sensores-arduino/sensor-de-ph-arduino-modulo-de-leitura-5316.html

Os demais componentes utilizados são:

- Arduino Nano

- Sensor de temperatura DHT11

- Display OLED 0.91

- Módulo Bluetooth HC-06:

- Protoboard 830 pontos:

- Conector P4 fêmea com borne para fonte de alimentação externa:

- Fonte de alimentação externa 9V:

- Jumpers Dupont macho-macho e macho-fêmea:

A figura abaixo mostra os componentes conectados:

Detalhes da implementação:

1) Alimentação externa: para fornecer tensão constante próxima dos 5V necessários para o sensor foi utilizada fonte de alimentação externa de 9V, ligando o positivo do conector P4 na entrada Vin do Arduino e o negativo no pino GND. O interessante é que também é possível conectar uma bateria de 9V usando um jack apropriado. É importante salientar que não é recomendado utilizar alimentação pela USB do Arduino por apresentar geralmente valores bem abaixo dos 5V necessários.
2) Foi utilizado um display OLED 0.91 para visualizar os valores de pH e temperatura. A alimentação do display é de 3.3V e o VCC do display é conectado ao pino 3V3 do Arduino.
3) DHT11: ligar normalmente o sensor DHT11 (não esquecendo do resistor de 10K entre o pino de DATA e o VCC). O pino de DATA está conectado na porta D2 do Arduino.
4) Módulo Bluetooth: o módulo Bluetooth está utilizando os pinos TX e RX do Arduino. Optamos por utilizar os mesmos pinos da comunicação serial padrão do Arduino para simplificar. Para fazer o upload do código através do cabo USB serial do Arduino basta desplugar o módulo da protoboard.
5) Sensor pH: o sensor é alimentado com 5V, a leitura de pH se dá pelo pino Po do módulo pH e este é conectado no pino A0 do Arduino. Os dois pinos de terra (alimentação e do eletrodo) são ligados no  GND do Arduino.

A imagem abaixo mostra o projeto como ficou:

 


No próximo post veremos o código do projeto e seus detalhes. Até a próxima!

Novo projeto: levitador acústico

Olá pessoal,

Depois de muito tempo sem postar vamos falar agora de um novo projeto que me despertou bastante interesse em implementá-lo embora não fosse um projeto de aplicação prática para o meu dia a dia. Ouvi falar do levitador acústico no Arduino Day 2018 e me interessou bastante e li o instructables do projeto do Asier Marzo. Vamos lá.

Como funciona a levitação acústica:

http://www.oarquivo.com.br/variedades/ciencia-e-tecnologia/4306-levita%C3%A7%C3%A3o-ac%C3%BAstica-2.html



Projeto Levitador Acústico do Instructables:

https://www.instructables.com/id/Acoustic-Levitator/


Vídeo do projeto:



Vídeo por Physics Girl explicando a física por trás do levitador acústico:

https://www.youtube.com/watch?time_continue=9&v=ABjRnSYw-4k


Como o projeto é bem detalhado no instructables os próximos posts serão sobre dicas de como implementar o projeto. Até mais!

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!