Font Size

Olá, caro(a) leitor(a)! Hoje vamos ver como é possível utilizar o Módulo Controlador PWM PCA9685 para facilitar a implementação de um braço robótico DIY que é controlado por 4 servomotores!

Módulo Controlador PWM PCA9685

Imagem 1 – Módulo PCA9685

Imagem do Braço robótico montado

Imagem 2 – Braço Robótico DIY

Materiais Utilizados:

Se você procura detalhes da montagem do braço, cheque nossa série de posts direcionados a esse Kit

Por que utilizar o PCA9685 nesse projeto ?

De forma geral, controlar múltiplos servomotores pode ser um pouco desafiador, principalmente no que diz respeito à alimentação e conexões, pois cada servo deve ser ligado à fonte e a uma porta PWM do microcontrolador.

Usando o PCA9685, você pode otimizar bastante as conexões, pois pode ligar todos os servomotores  diretamente a ele dessa forma:

demonstração de como ligar um servo ao módulo

Imagem 3 – Conectando um servo ao PCA9685

 

A alimentação também é facilitada, e além disso, você pode anexar o sistema  ao microcontrolador utilizando apenas 2 portas lógicas para controlar todos os servomotores!

Conhecendo o módulo:

O PCA9685 é um controlador de PWM que tem design especializado para lidar com servos, ele utiliza o protocolo I2C, e assim, pode usar apenas uma porta SDA  e uma SCL para controlar não somente os 4 necessários para esse projeto, mas até 16 servomotores diferentes!

Ligações do Módulo PCA9685 em um Arduino Nano

Imagem 4 – Ligações do Módulo em um Arduino Nano

 

Lembre-se de verificar quais são as portas SDA e SCL no seu microcontrolador, a imagem acima se refere às conexões no Arduino Nano.

Você pode ligar o pino VCC  à porta 5V do controlador, pois ele não servirá para alimentar o servos, apenas o módulo e seu microchip interno. Para isso você precisa de uma fonte de energia que mantenha entre 2A e 3A de corrente, e ligá-la nessa parte do módulo:

Local para ligar os cabos da fonte

Imagem 5 – Canais de alimentação dos Servomotores

 

A faixa de corrente mencionada de 2A a 3A é suficiente para operar 4 servos, pois cada um deles consome entre 250mA a 650mA. Já em um projeto com mais servos, se faz necessário o uso de uma fonte mais potente.

Preparando o código:

Para utilizar o componente, você precisa de 2 bibliotecas disponíveis no Arduino IDE, são elas:

  • Wire (já vem instalada por padrão, e serve para usar a comunicação I2C)
  • Adafruit PWM Servo Driver Library (deve ser instalada, serve para lidar com o módulo)
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

// Criar uma instância do controlador PWM
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

Em seguida, é preciso definir a faixa dos pulsos PWM

#define SERVOMIN  150 // Valor mínimo para o servo
#define SERVOMAX  600 // Valor máximo para o servo

Esses valores correspondem à duração dos pulsos, ou seja, definimos que ao receber 150 no PWM, o servo ficará na posição de 0°, se receber 600, fará o giro de 180° (ou o máximo que o seu servo permitir), e qualquer outro ângulo será expresso por um valor dentro desse intervalo.

Setup

void setup() {

  // Iniciar o driver PWM
  pwm.begin();

  // Ajustar a frequência para 60 Hz
  pwm.setPWMFreq(60);
}

O setup é bem simples para o Driver, basta iniciá-lo e declarar a frequência do sinal como 60Hz, pois é um valor ideal para comunicação com servos

Função de controle

 

  pwm.setPWM(0, 0, 375);

Veja como é uma função simples! Basta adicionar 3 parâmetros a ela, o primeiro define o canal, ou seja, qual dos servos você quer controlar no nosso caso será um número entre 0 e 3, pois vamos inserir os servos nos primeiros canais, como na imagem a seguir:

Na imagem, está a placa PCA9685 com 4 servomotores conectados a seus primeiros 4 canais

Imagem 6 – Servos Conectados à placa

 

Aqui a indicação de qual servo do braço ocupará cada canal do PCA9685

Imagem 7 – Correspondência dos canais com cada servomotor

 

O segundo parâmetro é o início do pulso, portanto iremos sempre utilizar 0 nessa aplicação, o que nos leva ao terceiro e último parâmetro, o valor correspondente ao ângulo desejado, que irá influenciar o braço da seguinte forma:

A imagem mostra a angulação que cada servomotor irá fazer, e qual movimento será realizado no braço

Imagem 8 – Esquemático da movimentação do braço

E pronto!!!

Agora que você já sabe como interagir com cada um dos servos usando o módulo, assim como conhece o mapeamento dos movimentos, já pode utilizar o braço normalmente, mapeando seus movimentos com potenciômetros, joysticks, ou conforme preferir.

 

Por último, vamos deixar o código de exemplo para que o braço realize a animação do segundo vídeo:

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

// Criar uma instância do driver PWM
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#define SERVOMIN  150 // Valor mínimo para o servo
#define SERVOMAX  600 // Valor máximo para o servo
int pwmValue = SERVOMIN;

void setup() {
  // Inicializar o driver PWM
  pwm.begin();

  // Ajustar a frequência para 60 Hz
  pwm.setPWMFreq(60);
}

void loop() {
//posição inicial
  pwm.setPWM(0, 0, 150);
  delay(1000);
  pwm.setPWM(1, 0, 375);
  delay(1000);
  pwm.setPWM(2, 0, 375);
  delay(1000);
  pwm.setPWM(3, 0, 600);
  delay(1000);
//vira para frente
  pwm.setPWM(0, 0, 375);
  delay(1000);
  //balança
  pwm.setPWM(2, 0, 480);
  delay(500);
  pwm.setPWM(2, 0, 375);
  delay(500);
  pwm.setPWM(2, 0, 480);
  delay(500);
  pwm.setPWM(2, 0, 375);
  delay(500);
  pwm.setPWM(2, 0, 480);
  delay(500);
  pwm.setPWM(2, 0, 375);
  delay(1000);
  //abre e fecha a garra
  pwm.setPWM(3, 0, 150);
  delay(1000);
  pwm.setPWM(3, 0, 600);
  delay(1000);
  //ao final ele volta à posição inicial
}

Até a próxima…

Obrigado pela leitura e aproveite para contar pra gente o que você achou, nos comentários abaixo!!!

 

4.50 avg. rating (89% score) - 2 votes