Como controlar servo motor com o módulo PWM PCA9685

O módulo PWM PCA9685 é um controlador usado para gerenciar múltiplos servos ou LEDs PWM com precisão através do protocolo I2C. Este módulo é amplamente utilizado com Arduino e outros microcontroladores em projetos de robótica devido à sua eficiência e versatilidade.

O módulo PWM PCA9685 conta com os 16 canais com saídas PWM independentes, podendo controlar até 16 servos. Este componente se destaca pela sua funcionalidade de endereçamento I2C flexível, que permite o uso de até 62 dispositivos no mesmo barramento, facilitando a expansão dos sistemas. Além disso, o PCA9685 é um driver PWM versátil que se adapta a uma ampla gama de aplicações de controle, marcando presença significativa em projetos de tecnologia avançada e inovação em sistemas de controle automatizado.

Diferente de outros dispositivos que podem necessitar de alimentação compartilhada, o módulo PCA9685 utiliza uma fonte de alimentação separada para o controle dos servos. Isso melhora a gestão de energia e a eficiência do sistema, pois o módulo conta com um conector de alimentação independente da alimentação do microcontrolador.

 Os 16 pinos PWM do módulo PWM PCA9685 são enumerados do 0 ao 15. Cada um destes pinos pode ser utilizado para controlar servomotores, LEDs ou outros dispositivos PWM. A interface I2C, através dos pinos SDA e SCL, simplifica a comunicação entre o microcontrolador e PCA9685, utilizando apenas dois pinos de controle.

A Figura 2 indica os pinos do módulo PWM PCA9685, que serão detalhados em seguida.

Alimentação:

– VCC: Alimenta o circuito lógico do PCA9685 com tensão de 3.3V ou 5V.
– GND: Conexão de terra.
– V+: Alimenta os servomotores ou LEDs conectados com 5V.

Pinos de Comunicação I2C:

– SDA: pino de dados para a comunicação I2C.
– SCL, pino de clock para a comunicação I2C.

Pinos de Saída PWM:

– Pinos PWM: 16 pinos de saída PWM usados para controlar servos ou LEDs. Cada pino pode gerar um sinal PWM independente.

OE (Output Enable):

– OE: Pino para habilitar ou desabilitar as saídas PWM.

Agora que já conhecemos as especificações e forma de funcionamento do módulo PWM PCA9685, vamos aprender como utilizá-lo na prática. Neste tutorial, vamos usar o módulo em conjunto com o Arduino para controlar 16 servo motores.

MATERIAIS NESCESSÁRIOS

1x Módulo PWM PCA9685;
1x Placa UNO SMD R3 Atmega328 compatível com Arduino UNO;
1x Cabo USB Tipo A-B compatível com Arduino UNO;
16x Micro Servo Motor 9G SG90;
1x Kit de Jumpers macho-fêmea;
1x Fonte de alimentação 5V de no mínimo 2A.

ESQUEMÁTICO DE LIGAÇÃO

Certifique-se que o circuito esteja desenergizado e, em seguida, monte o circuito seguindo as orientações abaixo.

Ao montar o circuito, observe os seguintes pontos:

• O pino GND do módulo deve ser conectado ao GND do Arduino;
• O pino VCC do módulo deve ser conectado ao 5V do Arduino;
• O pino SCL do módulo deve ser conectado à porta A5 do Arduino;
• O pino SDA do módulo deve ser conectado à porta A4 do Arduino;
• Cada servomotor possui três fios. O fio marrom deve ser conectado ao terminal GND do módulo, o fio vermelho deve ser ligado ao V+ e o fio amarelo deve ser conectado ao pino PWM;
• Conecte os servomotores nas entradas PWM do Módulo PCA9685 em sequência.

ATENÇÃO:
Para que o módulo funcione corretamente, é necessária uma alimentação independente da do Arduino. Portanto, conecte uma fonte de 5V ao módulo pelo conector de alimentação, para e a quantidade de servo utilizada, é necessária uma fonte de no mínimo 2A.

É necessário conectar a fonte de alimentação ao módulo antes de conectar o Arduino ao computador. Isso é crucial para prevenir sobrecarga e possíveis danos aos componentes.

ELABORANDO O CÓDIGO

Com o circuito montado, vamos a programação. A proposta desse projeto é controlar 16 servos utilizando o Módulo PWM PCA9685. Para tal, vamos fazer uso da biblioteca Adafruit PWM Servo Driver Library. Para instalá-la abra o Gerenciador de Bibliotecas do Arduino IDE pelo caminho: Rascunho > Incluir biblioteca > Gerenciar bibliotecas, ou pelo atalho Ctrl+Shift+I.

Ao adicionar, caso tenha dúvidas, veja nosso tutorial de Como adicionar biblioteca na Arduino IDE.

Nossa intenção no projeto é fazer com que todos os servos se movam igualmente. Para isso, precisamos nos certificar de que todos comecem na mesma posição e que todas as hélices sejam colocadas corretamente. Portanto, vamos sincronizar os servos antes de encaixar as hélices. Para isso, criamos um código que faz com que todos os servos girem para a posição 0. Logo após, podemos encaixar as hélices na mesma posição em todos os servos.

CÓDIGO PARA SINCRONIZAR OS SERVOS

Primeiro, incluímos as bibliotecas Wire.h, que permite usar o I2C, e Adafruit_PWMServoDriver.h, que é responsável pelo funcionamento do módulo. Logo após, criamos o objeto que usa o endereço padrão 0x40.

Definimos os parâmetros servomin, configurando o pulso em 150 milissegundo e o NUM_SERVOS que define a quantidade de servos, que no nosso caso é 16.

Na função setup(), iniciamos o PCA9685 usando a função pwm.begin() para e definimos a frequência em 60 Hz com a função pwm.setPWMFreq(60) PWM.
Um breve delay de 10ms deve ser adicionado ao final do setup para que o hardware estabilize após ser configurado.

Ainda na função setup, criamos um for para definir a posição do servo para posição 0.

Na função loop, não é necessário colocar nada.

No final, o código ficará da seguinte maneira:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// Cria o objeto PCA9685 usando o endereço I2C padrão 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

// Definições dos parâmetros do servo
#define SERVOMIN  150 // Este é o 'pulso mínimo' em milissegundos, que geralmente corresponde à posição 0
#define NUM_SERVOS  16 // Número de servos conectados ao PCA9685

void setup() 
  pwm.begin(); // Inicia o PCA9685
  pwm.setPWMFreq(60); // Ajusta a frequência do PWM para 60 Hz (típico para servos)

  delay(10);
  
  // Define a posição 0 para todos os servos
  for (int i = 0; i < NUM_SERVOS; i++) {
    pwm.setPWM(i, 0, SERVOMIN);
  }
}

void loop() {

}

Após transferir o código, os motores serão colocados na posição 0. Coloque as hélices em todos os servos da mesma maneira, garantindo que fiquem alinhadas para possibilitar um movimento síncrono ao final do projeto.

Agora, vamos ao código final do projeto.

CÓDIGO FINAL

Vamos iniciar incluindo as bibliotecas Wire.h e Adafruit_PWMServoDriver.h como no código anterior.

Em seguida, criamos o objeto PWM que utiliza por padrão o endereço I2C 0x40, que é usado para a comunicação com o módulo.

Definimos os parâmetros importantes: SERVOMIN e SERVOMAX, que determinam os pulsos mínimo e máximo em milissegundos para os servos, ajustáveis conforme necessário.

Também definimos o número de servos, NUM_SERVOS, que neste caso é 16, indicando quantos servos estão conectados ao módulo.

Na função setup(), iniciamos o PCA9685 usando a função pwm.begin() para e definimos a frequência em 60 Hz com a função pwm.setPWMFreq(60) PWM.
Um breve delay de 10ms deve ser adicionado ao final do setup para que o hardware estabilize após ser configurado.

Na função loop(), adicionamos um laço de repetição para mover todos os servos. todos os servos são movidos para a posição máxima de forma acelerada, aumentando o pulso de SERVOMIN para SERVOMAX.

Após atingir a posição máxima, outro laço de repetição é utilizado para mover todos os servos de volta para a posição mínima, também de forma acelerada.

O pulso é reduzido de SERVOMAX para SERVOMIN. Entre laços de repetição do efeito foram criados delays de 5ms para garantir a estabilidade.

No final, o código ficará da seguinte maneira:

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// Cria o objeto PCA9685 usando o endereço I2C padrão 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

// Definições dos parâmetros do servo
#define SERVOMIN  150 // Pulso mínimo (ajuste conforme necessário para seu servo)
#define SERVOMAX  600 // Pulso máximo (ajuste conforme necessário para seu servo)
#define NUM_SERVOS  16 // Número de servos conectados ao PCA9685

void setup() {
  
  pwm.begin(); // Inicia o PCA9685
  pwm.setPWMFreq(60); // Ajusta a frequência do PWM para 60 Hz (típico para servos)

  delay(10);
}

void loop() {
  // Move todos os servos para a posição máxima mais rapidamente
  for (uint16_t pulselen = SERVOMIN; pulselen < SERVOMAX; pulselen++) {
    for (int i = 0; i < NUM_SERVOS; i++) {
      pwm.setPWM(i, 0, pulselen);
    }
    delay(5); // Reduzido para tornar o movimento mais rápido
  }

  // Move todos os servos de volta para a posição mínima mais rapidamente
  for (uint16_t pulselen = SERVOMAX; pulselen > SERVOMIN; pulselen--) {
    for (int i = 0; i < NUM_SERVOS; i++) {
      pwm.setPWM(i, 0, pulselen);
    }
    delay(5); // Reduzido para tornar o movimento mais rápido
  }
}

---

Veja o vídeo de como ficou nosso projeto:

Espero ter ajudado, qualquer dúvida, deixe um comentário abaixo!

Obrigado.