Noções básicas e controle do servo motor Arduino

Publicado em por
Tempo de leitura: 8 minutes

Servo motores podem ser encontrados em braços robóticos, câmeras, tornos, máquinas CNC, impressoras e outras aplicações de engenharia onde a precisão e movimentos repetidos são necessários. Servo motores geralmente são compostos de motores DC que usam mecanismos de feedback para se mover com grande precisão de uma posição para outra. Os servos de baixo custo encontrados em projetos de fabricantes usam potenciômetros para registrar as tensões como posições no plano de rotação do servo. Freqüentemente, os servo motores contêm uma série de engrenagens que aceleram ou desaceleram e suavizam o movimento do motor DC. Por fim, os servo motores usam um circuito para controlar e enviar informações de feedback para um determinado controlador, que em nosso caso é uma placa Arduino (leia mais sobre servo motores aqui). Neste tutorial, uma placa Arduino será usada para alimentar e controlar um pequeno servo motor. Os fundamentos e a composição de um SG90 serão explorados, e a aplicação de vários servo-códigos e aplicações será dada para outro tipo de servo motor, o MG90S. O objetivo deste projeto é apresentar aos usuários o funcionamento de um servo motor, como o PWM (modulação por largura de pulso) controla um servo motor e como o Arduino pode fazer interface com servo motores para produzir os movimentos desejados com grande

 

Abaixo está uma série de fotografias representando os diferentes componentes contidos em um servo motor SG90 típico:

Fotos Originais.

Um vídeo do processo de redução de engrenagem é mostrado abaixo, onde o motor DC é enviado através de um estágio de redução de engrenagem, com uma fase de estabilização da engrenagem (o pólo do meio na imagem acima com o motor e o potenciômetro), e finalmente a engrenagem girando mais lenta que é usado para aplicações (a marcha superior). O vídeo mostra o SG90 abaixo de 5,0 V alimentado por uma placa Arduino, girando 1 grau aproximadamente a cada 17 milissegundos por 90 graus e depois parando.

Na próxima seção, outro servo motor, o MG90S, será usado para demonstrar a fiação e o controle do servo com uma placa Arduino.

 

Servo cabeamento e conceitos básicos de codificação com Arduino

O MG90S é outro pequeno servo motor semelhante ao SG90, mas pesa um pouco mais (14g) e tem engrenagens de metal em vez de plástico. O MG90S também é um pouco mais rápido que o SG90, o que é mais uma justificativa para o motivo de seu uso aqui. Tanto o MG90S quanto o SG90 têm a mesma fiação e usam código semelhante. Assim que saem da caixa, os servos MG90S funcionam com o código “Servo” prescrito do Arduino, que gira o servo para frente e para trás com base em sua biblioteca servo integrada. A biblioteca Arduino é um ótimo lugar para começar, pois realmente requer apenas algumas linhas de código. Primeiro, o servo precisa ser conectado a uma placa Arduino. A placa Arduino Uno é usada abaixo. O MG90S tem tecnicamente uma faixa de entrada de tensão de trabalho de 4,8 V – 6,0 V, portanto, qualquer Arduino de 5,0 V deve funcionar, presumindo que tenha recursos de modulação por largura de pulso (PWM). Felizmente, o Arduino usa um pulso de PWM de 20 ms em sua biblioteca de servo, que por acaso é o período do pulso de PWM em ambos os servos, então a programação necessária para fazer os servos funcionarem é mínima.

 

Lista de peças:

  • Arduino Uno
  • MG90S Micro Servo
  • Fios de jumpers

O diagrama de ligação para o tutorial é fornecido abaixo:

O código simples para replicar o .gif na seção anterior é fornecido abaixo. O processo realiza o seguinte procedimento:

  • Primeiro, gire para 0 graus para determinar o ponto de partida do motor

Loop infinito:

  1. Gire 90 graus em cerca de 3 segundos, aguarde 5 segundos
  2. Gire 180 graus em 3 segundos, aguarde 5 segundos
  3. Gire de volta a 90 graus em 3 segundos, aguarde 5 segundos
  4. Gire de volta para 0 graus em 3 segundos, aguarde 5 segundos
#include <Servo.h>

Servo servo_1; //servo controlador (podem existir vários)

int servo_pin = 3; // Pino PWM para servo controle
int pos = 0;    // posição inicial do servo

void setup() {
  servo_1.attach(servo_pin); // inicia o controle servo
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // vai de 0 graus a 180 graus
    // em passos de 1 grau
    servo_1.write(pos);              // diga ao servo para ir para a posição na variável 'pos'
    delay(15); // demora para permitir que o servo alcance a posição desejada
    if (pos==90){
      delay(5000); // aguarde 5 segundos, uma vez posicionado a 90 graus
    }
  }
  delay(5000); // wait 5 seconds after reaching 180 degrees
 
  for (pos = 180; pos >= 0; pos -= 1) { // vai de 180 graus a 0 graus
    servo_1.write(pos);                 // diga ao servo para ir para a posição na variável 'pos'
    delay(15);
    if (pos==90){
      delay(5000); // aguarde 5 segundos, uma vez posicionado a 90 graus
    }
  }
  delay(5000); // aguarde 5 segundos após chegar de volta a 0 graus
}

 

Controlando um Servo a partir do Monitor Serial

Agora que os princípios básicos de fiação e codificação de um servo foram introduzidos, tópicos mais avançados sobre o uso e controle de servos podem ser explorados. Nesta seção, o foco será no controle de um servo usando a porta serial. Resumindo, um ângulo inserido na porta serial (em graus) dirá ao Arduino para girar o servo para a posição fornecida. Este tipo de controle pode ser útil para braços robóticos, controle de câmera ou qualquer situação onde o ângulo é conhecido e precisa ser alterado de acordo com a entrada direta de um usuário.

Algumas das implementações usadas aqui também foram usadas no tutorial anterior, onde um LED RGB foi controlado usando a porta serial em um Arduino. Esse tutorial pode ser encontrado aqui, onde o controle dos pinos do Arduino é explorado em detalhes. Aqui, o foco está apenas em controlar um único pino Arduino para alterar o ângulo do servo motor usando modulação por largura de pulso.

#include <Servo.h>

Servo servo_1; // servo controlador (podem existir vários)

int servo_pin = 3; // Pino PWM para servo controle
int pos = 0;   // posição inicial do servo

void setup() {
  servo_1.attach(servo_pin); // inicia o controle servo
  Serial.begin(9600); // inicia o monitor serial
  servo_1.write(pos); // move o servo para 0 graus
  Serial.println("Posicionado em 0 Graus");
  Serial.println("Insira o ângulo desejado e pressione Enter");
}

void loop() {
  while (Serial.available()){
    String in_char = Serial.readStringUntil('\n'); // leia até a nova linha
    Serial.print("Movendo para: ");
    Serial.print(in_char);
    Serial.println(" Graus");
    servo_1.write(in_char.toInt()); // converter ângulo e escrever servo
    delay(in_char.toFloat()*(10.0/6.0)); // atraso para velocidade máxima
  }
}

Nota: Certifique-se de que o monitor serial está imprimindo um ‘Newline’ a cada entrada (marque próximo a 9600 baud)

A saída do código acima deve ser semelhante a esta no monitor serial:

 

Controlando um servo com um joystick

Um joystick também pode ser usado como uma ferramenta de controle para um servo. A metodologia envolve alguma geometria e compreensão de como um joystick funciona, mas não é muito complicada. Um joystick gira em um plano 2-D (a maioria também tem uma terceira dimensão – força, mas isso não será discutido aqui). Usando o Arduino novamente, podemos registrar os movimentos das direções xey do joystick e traduzi-los em movimentos angulares.

 

O movimento geométrico de um joystick pode ser representado da seguinte forma:

onde o ponto preto no triângulo é o botão que é movido em um joystick, e a convenção de movimento segue as setas. O símbolo grego θ representa o ângulo com o qual o joystick está operando e também determinará onde o servo motor será posicionado.

Podemos resolver para θ usando a função tangente:

Uma implementação do ângulo foi realizada no Arduino usando sua função ‘atan2 ()’ que produz o ângulo aproximado entre dois componentes direcionais. Abaixo está o código Arduino completo que implementa a tangente inversa para os valores do joystick. Ele também incorpora um deslocamento que faz com que os movimentos do joystick imitem os movimentos angulares do servo. A saída do ângulo pela tangente inversa abrange os valores negativos, então o ângulo foi corrigido para girar para valores negativos e imitar a convenção de rotação do servo MG90S. Por último, uma rotina de redução de jitter é usada para evitar que o servo se mova muito sem muito movimento do joystick. Tudo isso faz parte do código abaixo:

#include <Servo.h>
#include <math.h>

Servo servo_1; // servo controlador (podem existir vários)

int servo_pin = 3;  // Pino PWM para servo controle
int joy_pin_x = A0; // pino para joystick x-dir
int joy_pin_y = A1; // pino para joystick y-dir
int offset_x = 0; // subtraindo a localização x inicial do joystick
int offset_y = 0; // subtraindo a localização y inicial do joystick
int pos = 90;     // posição inicial do servo alinhada com o joystick
int prev_deg = 0; // destinado a reduzir o jitter
int x_prev = 0; // destinado a reduzir o jitter
int y_prev = 0; // reduzindo o jitter

void setup() {
  servo_1.attach(servo_pin); // inicia o controle servo
  Serial.begin(9600);
  servo_1.write(pos); // mover para o centro (joystick neutro)
  Serial.println("Posicionado em 90 graus");  
  offset_x = analogRead(joy_pin_x); // joystick inicial x-val
  offset_y = analogRead(joy_pin_y); // joystick inicial y-val
}

void loop() {
  int x_val = analogRead(joy_pin_x)-offset_x; // joystick relativo x
  int y_val = analogRead(joy_pin_y)-offset_y; // joystick relativo y
  if (abs(x_prev-x_val)<10 and abs(y_prev-y_val)<10){
    // reduz o jitter
  } else {
    x_prev = x_val;
    y_prev = y_val;
    float deg = 180-(int(atan2(x_val,y_val)*(180.0/PI))+90); // ângulo calc
    if (abs(deg-prev_deg)>2 and deg>0 and deg<180){
      servo_1.write(deg); // mover servo para localização do joystick
      delay(abs(deg-prev_deg)*(10.0/6.0));
      prev_deg = deg;
      Serial.println(deg); // imprimir o grau
    }
  }
}

 

 

Conclusão e Continuação

Servo motores são necessários para aplicações de engenharia tanto no mercado consumidor quanto no mercado industrial. Os servos podem ser encontrados em aeronaves, braços robóticos, máquinas CNC, impressoras, câmeras e uma infinidade de outras áreas de funcionamento mecânico que requerem velocidade, precisão e eficácia no controle. Neste tutorial, dois servo motores foram explorados. Um servo motor, o SG90, foi usado para demonstrar os componentes internos de um servo motor. O segundo servo, o MG90S, foi usado para demonstrar duas aplicações específicas de controle. Usando o Arduino como ponto de controle, a entrada serial foi usada como uma forma de inserir um ângulo desejado e fazer o servo girar para essa posição. Em segundo lugar, um joystick foi usado para responder a movimentos mecânicos em duas dimensões, que foram transformados em uma resposta angular para fazer o servo girar. Este tutorial é a primeira entrada de uma série dedicada a motores e atuadores, que ajudará engenheiros e fabricantes a explorar o mundo dos movimentos eletromecânicos.

 

Conclusão

Neste artigo, mostrei como usar um Servo SG90 e o MG90S com o Arduino. Espero que você tenha achado útil e informativo. Se sim, compartilhe com um amigo que também gosta de eletrônica e de fazer coisas!

Eu adoraria saber quais projetos você planeja construir (ou já construiu) com esses Servos. Se você tiver alguma dúvida, sugestão ou se achar que falta algo neste tutorial, por favor, deixe um comentário abaixo.

 
Twittar
Compartilhar
Compartilhar
0 Compart.