Início / Projetos Arduino / Projetos Squids / Intermediário / I23 - Testando suporte pan tilt para Arduino

---

I23 - Testando suporte pan tilt para Arduino

Angelo Luis Ferreira | 31/12/2024 Acessos: 239

Objetivo

Neste tutorial, nosso objetivo é mostrar como controlar dois micros servos motores 9g SG90 montados em um suporte "pan tilt" para a plataforma Arduino. Nele, o primeiro micro servo motor será responsável pele movimento horizontal de 180º (pan) fixado na base do suporte e o segundo servo motor controlará o movimento de inclinação vertical de 120º (tilt).

O projeto apenas ilustrará como pode funcionar um sistema de suporte plástico "pan tilt" controlado automaticamente pelo Arduino. A base rotacionará em 180º e depois a 90º dando início ao movimento de inclinação em 120º.

Definições

1. Suporte plástico "pan tilt" para Arduino é um acessório mecânico amplamente utilizado em projetos de eletrônica e robótica para movimentação precisa de componentes, como sensores, câmeras ou LEDs. Ele é composto por uma estrutura articulada que permite o movimento em dois eixos principais:

Pan (giro horizontal): Permite a rotação no eixo horizontal, movimentando o componente de um lado para o outro (esquerda e direita).

Tilt (giro vertical): Permite a rotação no eixo vertical, movimentando o componente para cima e para baixo.

Estrutura do Suporte Pan-Tilt

Material: Geralmente é feito de plástico leve e durável, o que reduz o peso total do projeto e facilita a montagem.

Compartimentos para Micro Servos: O suporte é projetado para acomodar micro servos motores (como os SG90 ou MG90S), que são responsáveis por realizar os movimentos de pan e tilt. Um servo motor é encaixado para controlar o eixo horizontal e outro para o eixo vertical.

Base de Fixação: O suporte possui uma base para ser fixado em superfícies, como uma estrutura de robô, uma bancada ou até um braço robótico.

Pontos de Encaixe: Vem com furos e suportes específicos para fixar câmeras pequenas, módulos de sensores (como sensores ultrassônicos) ou outros dispositivos que exijam movimentação.

Aplicações específicas

Sistemas de Rastreamento: Pode ser usado para movimentar sensores ultrassônicos em projetos que detectam obstáculos em diferentes direções.

Câmeras de Vigilância ou Projetos com OpenCV: Permite movimentar câmeras para capturar imagens ou vídeos em diferentes ângulos.

Braços Robóticos: Usado como uma articulação em robôs que precisam movimentar ferramentas ou dispositivos.

Projetos de Apontamento: Ideal para sistemas que requerem movimentação precisa de lasers ou LEDs.

2. Micro servo motor 9g: É um micro atuador eletromecânico que apresenta rotação do seu eixo proporcional ao comando emitido por um sinal digital, que pode ser por um microcontrolador, como pela placa Arduino, por exemplo. Portanto, com um micro servo motor é possível controlar a posição e a velocidade de rotação do seu eixo com precisão. Por estas características, os servos motores são muito utilizados em projetos de robótica e mecatrônica.

Referências

I18 - Como usar o micro servo motor 9g SG90 com Arduino

S1 - Montagem Suporte Pan Tilt controlado com Arduino e Micro Servos Motores

Aplicação

O suporte Pan-Tilt é essencial em projetos didáticos e práticos que exigem mobilidade em dois eixos, sendo uma peça fundamental para explorar conceitos de mecânica, eletrônica e automação.

Componentes necessários

Referência	Componente	Quantidade	Imagem	Observação
Protoboard	Protoboard 830 pontos	1		No mínimo utilizar protoboard com 400 pontos
Jumpers	Kit cabos ligação macho / macho	1
Micro Servo Motor	Micro Servo 9g SG90	2		Voltagem de Operação 3,0 - 7,2V Ângulo de rotação 180 graus Velocidade 0,12 seg/60Graus (4,8V) sem carga Torque 1,2 kg.cm (4,8V) e 1,6 kg.cm (6,0V) Temperatura de Operação -30C ~ +60C Tipo de Engrenagem Nylon Tamanho cabo 245mm Dimensões 32 x 30 x 12mm Peso 9g (datasheet)
Suporte Pan Tilt	Suporte Pan Tilt plástico	1		Suporte plástico para sistema Pan Tilt Deverão ser utilizados 2 micros servos motores 9G como atuadores S1 - Montagem Suporte Pan Tilt
Arduino UNO	Arduino UNO R3	1		Você poderá utilizar uma placa Arduino UNO original ou similar

Montagem do Circuito

Conecte os componentes no Protoboard como mostra a figura abaixo. Verifique cuidadosamente os cabos de ligação antes de ligar seu Arduino. Lembre-se que o Arduino deve estar totalmente desconectado da energia elétrica enquanto você monta o circuito.

Atenção

1. Faça a montagem do suporte "pan tilt" conforme o tutorial: S1 - Montagem Suporte Pan Tilt controlado com Arduino e Micro Servos Motores.

2. A montagem dos módulos micro servo motor 9g SG90 deve seguir a configuração abaixo:

• Cabo marrom (ou preto em algumas marcas) - Deve ser conectado ao pino GND do Arduino ou ao polo negativo de uma fonte de alimentação externa
• Cabo vermelho - Deve ser conectado a um pino 5V do Arduino ou ao polo positivo de uma fonte de alimentação externa
• Cabo laranja - Deve ser conectado a um pino digital do Arduino configurado como saída. No projeto, utilizamos o pino 9 do Arduino para o motor 1 (motor pan - horizontal) e o pino 10 para o motor 2 (motor tilt - vertical).

2.1. Utilize "jumpers" macho-macho para fazer as conexões com o Arduino.

2.2. No projeto usamos as seguintes conexões:

3. A montagem do nosso projeto foi realizada em um protoboard 400 pontos:

Código do Projeto (Sketch)

1) Faça o download e abra o arquivo projetoI23.ino no IDE do Arduino: DOWNLOAD - projetoI23.ino

 Se preferir, copie e cole o código abaixo no IDE do Arduino:

/*******************************************************************************
*
*    I23: Testando um suporte pan tilt usando 2 micro-servos motores - Arduino
*    Autor: Angelo Luis Ferreira
*    Data: 31/12/2025
*    
*             http://squids.com.br/arduino             
*
*******************************************************************************/
#include <Servo.h>        //biblioteca para controle do servo motor

// instâncias para os servos
Servo servo1;             // Cria um objeto servo1 para controle do servo motor 1
Servo servo2;             // Cria um objeto servo2 para controle do servo motor 2

// variáveis e constantes globais
int pos = 0;                              // variável para armazenar a posição do servo
byte stopPos;                             // variável para amazenar posições de parada do servo
const byte stepPos = 15;                  // define a incremento para parar o servo (a cada 15 graus)
const byte servo1Pin = 9;                 // Pino digital 9 conectado no servo1 (base - pan)
const byte servo2Pin = 10;                // Pino digital 10 conectado no servo2 (inclinação - tilt)

void setup() {
// inicialização dos servos
servo1.attach(servo1Pin);   // Inicializa servo1 pino 9 (horizontal - base)
servo2.attach(servo2Pin);   // Inicializa servo2 pino 10 (vertical - inclinação)
// define as posições iniciais dos servos
servo1.write(0);            // Inicia o servo1 em 0 graus
servo2.write(0);            // Inicia o servo2 em 0 graus                  
}

void loop() {
  // movimento horizontal do servo1 (pan)
  runServo1H(0,180);          // servidor 1 vai da posição 0 até 180º (pan)
  runServo1A(180,0);          // servidor 1 volta para a posição 0º
  runServo1H(0,90);           // servidor 1 vai da posição 0 até 90º (pan)
  delay(1000);                // espera 1 segundo

  // movimento vertical do servo2 (tilt)
  stopPos = 0;                // posição de parada em 0º (para o servidor 2)
  runServo2(0,120);           // servidor 2 vai da posição 0 até 120º (tilt)
  delay(1000);                // espera 1 segundo

  // retorno do servo1 para posição inicial    
  stopPos = 90;               // posição de parada em 90º (para o servidor 1)
  runServo1A(90,0);           //  servidor 1 volta para a posição 0º
  delay(1000);                // espera 1 segundo
}

void runServo1H(int x, int y) {
  // vai de zero a 180º e para por 500ms a cada 15º
  for (pos = x; pos <= y; pos += 1) {   // vai de zero a 180 graus, girando o eixo a cada 1º
    if (pos == stopPos) {               // para o servo durante 500ms a cada 15 graus
      delay(500);                       // espera 500ms
      stopPos += stepPos;               // acrescenta mais 15 graus (para a próxima parada)
    }
    servo1.write(pos);                  // diz ao servo para ir para a posição da variável 'pos'
    delay(15);                          // espera 15ms para o servo alcançar a posição
  }
  stopPos = 180;                        // posição de parada em 180º
}

 // volta para 0º e a cada 15º
void runServo1A(int x, int y) {
  // vai de 180º a 0º e para por 500ms a cada 15º
  for (pos = x; pos >= y; pos -= 1) {      // vai de 180º para a posição inicial, girando o eixo a cada 1º
    if (pos == stopPos) {                  // para o servo durante 500ms a cada 15 graus
       delay(500);                         // espera 500ms
       stopPos -= stepPos;                 // acrescenta mais 15 graus (para a próxima parada)
    }
    servo1.write(pos);                     // diz ao servo para ir para a posição da variável 'pos'
    delay(15);                             // espera 15ms para o servo alcançar a posição
  }
  stopPos = 0;                             // posição de parada em 0º
}

void runServo2(int x, int y) {
  // vai de zero a 180º e para por 500ms a cada 15º
  for (pos = x; pos <= y; pos += 1) {     // vai de zero a 180 graus, girando o eixo a cada 1º
     if (pos == stopPos) {                // para o servo durante 500ms a cada 15 graus
       delay(500);                        // espera 500ms
       stopPos += stepPos;                // acrescenta mais 15 graus (para a próxima parada)
     }
    servo2.write(pos);                    // diz ao servo para ir para a posição da variável 'pos'
    delay(15);                            // espera 15ms para o servo alcançar a posição
  }
  stopPos = 120;
   // vai de 180º a 0º e para por 500ms a cada 15º
   for (pos = 120; pos >= 0; pos -= 1) {   // vai de 180º para a posição inicial, girando o eixo a cada 1º
   if (pos == stopPos) {                   // para o servo durante 500ms a cada 15 graus
       delay(500);                         // espera 500ms
       stopPos -= stepPos;                 // acrescenta mais 15 graus (para a próxima parada)
     }
    servo2.write(pos);                     // diz ao servo para ir para a posição da variável 'pos'
    delay(15);                             // espera 15ms para o servo alcançar a posição
  }
  stopPos = stepPos;                       // define a primeira parada de cada ciclo em 15 graus  
}

Vídeo

Como o projeto deve funcionar

Movimento do Servo 1 (Pan):

• Primeiro, o Servo 1 gira horizontalmente de 0° a 180° em incrementos de 1°, parando a cada 15° por 500 ms. Depois, retorna de 180° a 0° no mesmo padrão.
• Em seguida, ele realiza um giro de 0° a 90° e para por 1 segundo.

Movimento do Servo 2 (Tilt):

• O Servo 2 inclina verticalmente de 0° a 120°, também parando a cada 15° por 500 ms.
• Depois, retorna de 120° para 0° e para por mais 1 segundo.

Movimento do Servo 1 (Pan):

• Retorna para a posição inicial e para por 1 segundo para reiniciar o ciclo.

Ciclo Completo:

• Após concluir os movimentos, o processo se reinicia, criando um movimento contínuo e controlado nos dois eixos.

Observação Importante

A posição na montagem dos micros servos motores é muito importante para garantir que eles possam atingir os ângulos especificados (180º no movimento horizontal e 120º no movimento vertical).

Observe que o ângulo máximo para o movimento vertical é de 120º, diferente do movimento horizontal, que permite 180º. Isso ocorre porque o servo motor responsável pelo movimento vertical foi montado inicialmente com um ângulo aproximadamente 60º em relação ao eixo horizontal. Com essa configuração, o motor não consegue atingir o limite de 180º devido à restrição física imposta pela posição inicial de montagem.

Se desejar ampliar o movimento vertical para um ângulo maior, será necessário ajustar a posição de montagem do micro servo. Para isso, remova o parafuso indicado na imagem acima e, com muito com cuidado para evitar danos ao suporte, solte e reposicione o servo motor, ajustando-o para uma posição completamente horizontal ou para outro ângulo que melhor atenda às suas necessidades.

O mesmo procedimento pode ser realizado no micro servo responsável pelo movimento horizontal (pan), ajustando a posição de montagem para que ele inicie no ângulo que melhor atenda às necessidades do seu projeto.

Entendendo o projeto

O projeto foi criado para demonstrar o controle de servos motores em dois eixos (horizontal e vertical), com paradas intermediárias programadas. Ele é útil para aplicações como sistemas de rastreamento, câmeras de vigilância ou mapeamento de áreas.

Estrutura e Funcionamento

1. Hardware

• Servo 1 (Pan): Conectado ao pino 9 do Arduino. Controla o movimento horizontal (giro da base do suporte).
• Servo 2 (Tilt): Conectado ao pino 10 do Arduino. Controla o movimento vertical (inclinação do suporte).

2. Configuração Inicial - setup()

• Ambos os servos são configurados para os pinos correspondentes.
• Os servos são posicionados na posição 0° ao inicializar o Arduino.

3. Funções Auxiliares

• runServo1H(int x, int y): Movimenta o Servo 1 (horizontal) do ângulo inicial x até o ângulo final y, com paradas intermediárias a cada 15°.
• runServo1A(int x, int y): Movimenta o Servo 1 no sentido inverso, do ângulo x para o ângulo y, com paradas intermediárias.
• runServo2(int x, int y): Controla o Servo 2 (vertical), movimentando de 0° a 120° com paradas a cada 15°. Em seguida, retorna de 120° para 0° com paradas a cada 15º.

4. Este projeto pode ser usado para:

• Demonstração didática: Ensinar o controle de servos motores em projetos Arduino.
• Câmeras motorizadas: Movimentação de câmeras para vigilância ou rastreamento.
• Sistemas de mapeamento: Posicionar sensores em diferentes ângulos para mapear ambientes.

Comentários