Braço de robô DIY Arduino com controle de smartphone

Neste tutorial, aprenderemos como fazer um braço robótico Arduino que pode ser controlado e programado sem fio usando um aplicativo Android personalizado. Mostrarei todo o processo de construção, desde o design e impressão 3D das partes do robô, conexão dos componentes eletrônicos e programação do Arduino, até o desenvolvimento de nosso próprio aplicativo Android para controlar o Robot Arm.

Você pode assistir ao vídeo a seguir ou ler o tutorial escrito abaixo.

Visão geral

Usando os controles deslizantes do aplicativo, podemos controlar manualmente o movimento de cada servo ou eixo do braço do robô. Também usando o botão “Salvar” podemos gravar cada posição ou passo e então o braço do robô pode executar automaticamente e repetir esses passos. Com o mesmo botão, podemos pausar a operação automática, bem como redefinir ou excluir todas as etapas para que possamos gravar novas.

Modelo 3D do braço do robô do Arduino

Para começar, projetei o Robot Arm usando o software de modelagem 3D Solidworks. O braço tem 5 graus de liberdade.

Para os primeiros 3 eixos, a cintura, o ombro e o cotovelo, usei os servos MG996R, e para os outros 2 eixos, a rotação do pulso e o pitch do pulso, assim como a pinça usei os micro servos SG90 menores.

Você pode encontrar e baixar este modelo 3D, bem como explorá-lo em seu navegador no Thangs:

Baixe o modelo 3D de montagem de Thangs.

Obrigado Thangs por apoiar este tutorial.

Arquivos STL para impressão 3D:

Arquivos STL do braço do robô do Arduino

1 arquivo(s) Download de 0,00 KB

Impressão 3D do braço do robô

Usando minha nova impressora 3D, Creality CR-10, imprimi em 3D todas as peças do braço do robô Arduino.

Aqui eu gostaria de dar um alô para Banggood.com por me fornecer esta incrível impressora 3D. A qualidade de impressão do Creality CR-10 é incrível pelo seu preço e o que também é ótimo é que ele vem quase 90% pré-montado.

Para completar a montagem, basta conectar as partes superior e inferior dos quadros usando alguns parafusos e suportes e, em seguida, conectar os componentes eletrônicos com a caixa de controle usando os cabos fornecidos.

Antes de experimentá-lo, é recomendável verificar se as rodas do rolo estão apertadas o suficiente e, se não estiverem, você pode simplesmente usar as porcas excêntricas para apertá-las. E é isso, depois de nivelar sua mesa de impressão 3D, você está pronto para transformar suas criações 3D em realidade.

Eu tinha todas as peças para o Arduino Robot Arm prontas em apenas algumas horas.

Leia mais:Os 15 principais acessórios e ferramentas de impressora 3D obrigatórios

Montagem do braço do robô

Ok, agora estamos prontos para montar o braço do robô. Comecei com a base na qual fixei o primeiro servo motor usando os parafusos incluídos na embalagem. Então, no eixo de saída do servo, prendi um chifre redondo com um parafuso.

E em cima coloquei a parte de cima e prendi com dois parafusos.

Aqui, novamente, primeiro vai o servo, depois o chifre redondo na próxima parte e, em seguida, eles são presos um ao outro usando o parafuso no eixo de saída.

Podemos notar aqui que no eixo do ombro é uma boa ideia incluir algum tipo de mola ou no meu caso usei um elástico para dar uma ajuda ao servo porque este servo carrega todo o peso do resto do braço também como carga útil.

Da mesma forma, continuei a montar o resto do braço do robô. Quanto ao mecanismo da garra, usei alguns parafusos e porcas de 4 milímetros para montá-lo.

Finalmente, conectei o mecanismo de garra no último servo e o braço do robô Arduino foi concluído.

Diagrama de circuito do braço do robô do Arduino

A próxima etapa é conectar a eletrônica. O diagrama de circuito deste projeto é realmente bastante simples. Precisamos apenas de uma placa Arduino e um módulo Bluetooth HC-05 para comunicação com o smartphone. Os pinos de controle dos seis servo motores são conectados a seis pinos digitais da placa Arduino.

Para alimentar os servos, precisamos de 5V, mas isso deve vir de uma fonte de alimentação externa porque o Arduino não é capaz de lidar com a quantidade de corrente que todos eles podem consumir. A fonte de alimentação deve ser capaz de lidar com pelo menos 2 A de corrente. Então, depois de conectar tudo, podemos passar para a programação do Arduino e fazer o aplicativo para Android.

Você pode obter os componentes necessários para este exemplo nos links abaixo:

Servomotor MG996R……………………….….
SG90 Micro Servo Motor ……..…….….…….
Módulo Bluetooth HC-05 ………………….…
Placa Arduino …………………………………….
Fonte de alimentação CC de 5V 2A ………………….…..

Código do braço do robô do Arduino

Como o código é um pouco mais longo, para melhor entendimento, postarei o código fonte do programa em seções com descrição de cada seção. E no final deste artigo vou postar o código fonte completo.

Então, primeiro precisamos incluir a biblioteca SoftwareSerial para a comunicação serial do módulo Bluetooth, bem como a biblioteca servo. Ambas as bibliotecas estão incluídas no IDE do Arduino para que você não precise instalá-las externamente. Em seguida, precisamos definir os seis servos, o módulo Bluetooth HC-05 e algumas variáveis para armazenar a posição atual e anterior dos servos, bem como arrays para armazenar as posições ou os passos para o modo automático.

#include <SoftwareSerial.h>
#include <Servo.h>

Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;

SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
String dataIn = "";Code language: Arduino (arduino)

Na seção de configuração, precisamos inicializar os servos e o módulo Bluetooth e mover o braço do robô para sua posição inicial. Fazemos isso usando a função write() que simplesmente move o servo para qualquer posição de 0 a 180 graus.

void setup() {
  servo01.attach(5);
  servo02.attach(6);
  servo03.attach(7);
  servo04.attach(8);
  servo05.attach(9);
  servo06.attach(10);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  // Robot arm initial position
  servo1PPos = 90;
  servo01.write(servo1PPos);
  servo2PPos = 150;
  servo02.write(servo2PPos);
  servo3PPos = 35;
  servo03.write(servo3PPos);
  servo4PPos = 140;
  servo04.write(servo4PPos);
  servo5PPos = 85;
  servo05.write(servo5PPos);
  servo6PPos = 80;
  servo06.write(servo6PPos);
}Code language: Arduino (arduino)

Em seguida, na seção de loop, usando a função Bluetooth.available() , verificamos constantemente se há algum dado recebido do Smartphone. Se true, usando a função readString() lemos os dados como string e os armazenamos na variável dataIn. Dependendo dos dados recebidos, diremos ao braço do robô o que fazer.

// Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();  // Read the data as stringCode language: Arduino (arduino)

Aplicativo de controle para Android

Vamos dar uma olhada no aplicativo Android agora e ver que tipo de dados ele está realmente enviando para o Arduino.

Eu fiz o aplicativo usando o aplicativo online do MIT App Inventor e veja como funciona. Na parte superior temos dois botões para conectar o smartphone ao módulo Bluetooth HC-05. Então no lado esquerdo temos uma imagem do braço do robô, e no lado direito temos os seis sliders para controlar os servos e um slider para o controle de velocidade.

Cada slider tem um valor inicial, mínimo e máximo diferente que se adapta às articulações do braço do robô. Na parte inferior do aplicativo, temos três botões, SAVE, RUN e RESET através dos quais podemos programar o braço do robô para funcionar automaticamente. Há também uma etiqueta abaixo que mostra o número de etapas que salvamos. No entanto, para obter mais detalhes sobre como construir aplicativos como este usando o MIT App Inventor, você pode verificar meu outro tutorial detalhado para ele.

Ok, agora vamos ver o programa ou os blocos por trás do aplicativo. Primeiro, do lado esquerdo temos os blocos para conectar o smartphone ao módulo Bluetooth.

Em seguida, temos os blocos deslizantes para o controle da posição do servo e os blocos de botões para a programação do braço do robô. Então se mudarmos a posição do slider, usando a função Bluetooth .SendText, enviamos um texto para o Arduino. Este texto consiste em um prefixo que indica qual controle deslizante foi alterado, bem como o valor atual do controle deslizante.

Aqui está um arquivo para download do projeto MIT App Inventor acima, bem como o aplicativo Android pronto para ser instalado em seu smartphone:

Arduino Robot Arm Control MIT App Inventor Arquivo de projeto

1 arquivo(s) Download de 24,85 KB

Aplicativo Android de controle de braço robótico do Arduino

1 arquivo(s) Download de 2,57 MB
Portanto, no Arduino, usando a função startsWith() verificamos o prefixo de cada dado recebido e assim sabemos o que fazer a seguir. Por exemplo, se o prefixo for “s1”, sabemos que precisamos mover o servo número um. Usando a função substring() obtemos o texto restante, ou esse é o valor da posição, convertemos em inteiro e usamos o valor para mover o servo para essa posição.

// If "Waist" slider has changed value - Move Servo 1 to position
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length()); // Extract only the number. E.g. from "s1120" to "120"
      servo1Pos = dataInS.toInt();  // Convert the string into integerCode language: Arduino (arduino)

Aqui podemos simplesmente chamar a função write() e o servo irá para essa posição, mas dessa forma o servo funcionará em sua velocidade máxima, o que é demais para o braço do robô. Em vez disso, precisamos controlar a velocidade dos servos, então usei alguns loops FOR para mover gradualmente o servo da posição anterior para a atual, implementando um tempo de atraso entre cada iteração. Ao alterar o tempo de atraso, você pode alterar a velocidade do servo.

// We use for loops so we can control the speed of the servo
      // If previous position is bigger then current position
      if (servo1PPos > servo1Pos) {
        for ( int j = servo1PPos; j >= servo1Pos; j--) {   // Run servo down
          servo01.write(j);
          delay(20);    // defines the speed at which the servo rotates
        }
      }
      // If previous position is smaller then current position
      if (servo1PPos < servo1Pos) {
        for ( int j = servo1PPos; j <= servo1Pos; j++) {   // Run servo up
          servo01.write(j);
          delay(20);
        }
      }
      servo1PPos = servo1Pos;   // set current position as previous position
    }Code language: Arduino (arduino)

O mesmo método é usado para acionar cada eixo do braço do robô.

Abaixo deles está o botão SALVAR. Se pressionarmos o botão SAVE, a posição de cada servo motor é armazenada em um array. A cada pressionamento, o índice aumenta para que a matriz seja preenchida passo a passo.

// If button "SAVE" is pressed
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
    }Code language: Arduino (arduino)

Então, se pressionarmos o botão RUN, chamamos a função personalizada runservo() que executa as etapas armazenadas. Vamos dar uma olhada nesta função. Então aqui nós executamos as etapas armazenadas repetidamente até pressionarmos o botão RESET. Usando o loop FOR percorremos todas as posições armazenadas nos arrays e ao mesmo tempo verificamos se temos algum dado de entrada do smartphone. Este dado pode ser o botão RUN/PAUSE, que pausa o robô, e se for clicado novamente continua com os movimentos automáticos. Além disso, se alterarmos a posição do controle deslizante de velocidade, usaremos esse valor para alterar o tempo de atraso entre cada iteração nos loops FOR abaixo, que controlam a velocidade dos servo motores.

// Automatic mode custom function - run the saved steps
void runservo() {
  while (dataIn != "RESET") {   // Run the steps over and over again until "RESET" button is pressed
    for (int i = 0; i <= index - 2; i++) {  // Run through all steps(index)
      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.readString();
        if ( dataIn == "PAUSE") {           // If button "PAUSE" is pressed
          while (dataIn != "RUN") {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if ( dataIn == "RESET") {     
                break;
              }
            }
          }
        }
        // If SPEED slider is changed
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt(); // Change servo speed (delay time)
        }
      }
      // Servo 1
      if (servo01SP[i] == servo01SP[i + 1]) {
      }
      if (servo01SP[i] > servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
          servo01.write(j);
          delay(speedDelay);
        }
      }
      if (servo01SP[i] < servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
          servo01.write(j);
          delay(speedDelay);
        }
      }Code language: Arduino (arduino)

De maneira semelhante, conforme explicado anteriormente, com essas instruções IF e loops FOR, movemos os servos para a próxima posição. Por fim, se pressionarmos o botão RESET, limparemos todos os dados dos arrays para zero e também redefiniremos o índice para zero para que possamos reprogramar o braço do robô com novos movimentos.

// If button "RESET" is pressed
    if ( dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
      memset(servo02SP, 0, sizeof(servo02SP));
      memset(servo03SP, 0, sizeof(servo03SP));
      memset(servo04SP, 0, sizeof(servo04SP));
      memset(servo05SP, 0, sizeof(servo05SP));
      memset(servo06SP, 0, sizeof(servo06SP));
      index = 0;  // Index to 0
    }Code language: Arduino (arduino)

E é isso, agora podemos aproveitar e nos divertir com o braço do robô.

Aqui está o código completo do Arduino Robot Arm:

/*        
       DIY Arduino Robot Arm Smartphone Control  
        by Dejan, www.HowToMechatronics.com  
*/

#include <SoftwareSerial.h>
#include <Servo.h>

Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;

SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
String dataIn = "";

void setup() {
  servo01.attach(5);
  servo02.attach(6);
  servo03.attach(7);
  servo04.attach(8);
  servo05.attach(9);
  servo06.attach(10);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  // Robot arm initial position
  servo1PPos = 90;
  servo01.write(servo1PPos);
  servo2PPos = 150;
  servo02.write(servo2PPos);
  servo3PPos = 35;
  servo03.write(servo3PPos);
  servo4PPos = 140;
  servo04.write(servo4PPos);
  servo5PPos = 85;
  servo05.write(servo5PPos);
  servo6PPos = 80;
  servo06.write(servo6PPos);
}

void loop() {
  // Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();  // Read the data as string
    
    // If "Waist" slider has changed value - Move Servo 1 to position
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length()); // Extract only the number. E.g. from "s1120" to "120"
      servo1Pos = dataInS.toInt();  // Convert the string into integer
      // We use for loops so we can control the speed of the servo
      // If previous position is bigger then current position
      if (servo1PPos > servo1Pos) {
        for ( int j = servo1PPos; j >= servo1Pos; j--) {   // Run servo down
          servo01.write(j);
          delay(20);    // defines the speed at which the servo rotates
        }
      }
      // If previous position is smaller then current position
      if (servo1PPos < servo1Pos) {
        for ( int j = servo1PPos; j <= servo1Pos; j++) {   // Run servo up
          servo01.write(j);
          delay(20);
        }
      }
      servo1PPos = servo1Pos;   // set current position as previous position
    }
    
    // Move Servo 2
    if (dataIn.startsWith("s2")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo2Pos = dataInS.toInt();

      if (servo2PPos > servo2Pos) {
        for ( int j = servo2PPos; j >= servo2Pos; j--) {
          servo02.write(j);
          delay(50);
        }
      }
      if (servo2PPos < servo2Pos) {
        for ( int j = servo2PPos; j <= servo2Pos; j++) {
          servo02.write(j);
          delay(50);
        }
      }
      servo2PPos = servo2Pos;
    }
    // Move Servo 3
    if (dataIn.startsWith("s3")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo3Pos = dataInS.toInt();
      if (servo3PPos > servo3Pos) {
        for ( int j = servo3PPos; j >= servo3Pos; j--) {
          servo03.write(j);
          delay(30);
        }
      }
      if (servo3PPos < servo3Pos) {
        for ( int j = servo3PPos; j <= servo3Pos; j++) {
          servo03.write(j);
          delay(30);
        }
      }
      servo3PPos = servo3Pos;
    }
    // Move Servo 4
    if (dataIn.startsWith("s4")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo4Pos = dataInS.toInt();
      if (servo4PPos > servo4Pos) {
        for ( int j = servo4PPos; j >= servo4Pos; j--) {
          servo04.write(j);
          delay(30);
        }
      }
      if (servo4PPos < servo4Pos) {
        for ( int j = servo4PPos; j <= servo4Pos; j++) {
          servo04.write(j);
          delay(30);
        }
      }
      servo4PPos = servo4Pos;
    }
    // Move Servo 5
    if (dataIn.startsWith("s5")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo5Pos = dataInS.toInt();
      if (servo5PPos > servo5Pos) {
        for ( int j = servo5PPos; j >= servo5Pos; j--) {
          servo05.write(j);
          delay(30);
        }
      }
      if (servo5PPos < servo5Pos) {
        for ( int j = servo5PPos; j <= servo5Pos; j++) {
          servo05.write(j);
          delay(30);
        }
      }
      servo5PPos = servo5Pos;
    }
    // Move Servo 6
    if (dataIn.startsWith("s6")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo6Pos = dataInS.toInt();
      if (servo6PPos > servo6Pos) {
        for ( int j = servo6PPos; j >= servo6Pos; j--) {
          servo06.write(j);
          delay(30);
        }
      }
      if (servo6PPos < servo6Pos) {
        for ( int j = servo6PPos; j <= servo6Pos; j++) {
          servo06.write(j);
          delay(30);
        }
      }
      servo6PPos = servo6Pos; 
    }
    // If button "SAVE" is pressed
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
    }
    // If button "RUN" is pressed
    if (dataIn.startsWith("RUN")) {
      runservo();  // Automatic mode - run the saved steps 
    }
    // If button "RESET" is pressed
    if ( dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
      memset(servo02SP, 0, sizeof(servo02SP));
      memset(servo03SP, 0, sizeof(servo03SP));
      memset(servo04SP, 0, sizeof(servo04SP));
      memset(servo05SP, 0, sizeof(servo05SP));
      memset(servo06SP, 0, sizeof(servo06SP));
      index = 0;  // Index to 0
    }
  }
}

// Automatic mode custom function - run the saved steps
void runservo() {
  while (dataIn != "RESET") {   // Run the steps over and over again until "RESET" button is pressed
    for (int i = 0; i <= index - 2; i++) {  // Run through all steps(index)
      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.readString();
        if ( dataIn == "PAUSE") {           // If button "PAUSE" is pressed
          while (dataIn != "RUN") {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if ( dataIn == "RESET") {     
                break;
              }
            }
          }
        }
        // If speed slider is changed
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt(); // Change servo speed (delay time)
        }
      }
      // Servo 1
      if (servo01SP[i] == servo01SP[i + 1]) {
      }
      if (servo01SP[i] > servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
          servo01.write(j);
          delay(speedDelay);
        }
      }
      if (servo01SP[i] < servo01SP[i + 1]) {
        for ( int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
          servo01.write(j);
          delay(speedDelay);
        }
      }

      // Servo 2
      if (servo02SP[i] == servo02SP[i + 1]) {
      }
      if (servo02SP[i] > servo02SP[i + 1]) {
        for ( int j = servo02SP[i]; j >= servo02SP[i + 1]; j--) {
          servo02.write(j);
          delay(speedDelay);
        }
      }
      if (servo02SP[i] < servo02SP[i + 1]) {
        for ( int j = servo02SP[i]; j <= servo02SP[i + 1]; j++) {
          servo02.write(j);
          delay(speedDelay);
        }
      }

      // Servo 3
      if (servo03SP[i] == servo03SP[i + 1]) {
      }
      if (servo03SP[i] > servo03SP[i + 1]) {
        for ( int j = servo03SP[i]; j >= servo03SP[i + 1]; j--) {
          servo03.write(j);
          delay(speedDelay);
        }
      }
      if (servo03SP[i] < servo03SP[i + 1]) {
        for ( int j = servo03SP[i]; j <= servo03SP[i + 1]; j++) {
          servo03.write(j);
          delay(speedDelay);
        }
      }

      // Servo 4
      if (servo04SP[i] == servo04SP[i + 1]) {
      }
      if (servo04SP[i] > servo04SP[i + 1]) {
        for ( int j = servo04SP[i]; j >= servo04SP[i + 1]; j--) {
          servo04.write(j);
          delay(speedDelay);
        }
      }
      if (servo04SP[i] < servo04SP[i + 1]) {
        for ( int j = servo04SP[i]; j <= servo04SP[i + 1]; j++) {
          servo04.write(j);
          delay(speedDelay);
        }
      }

      // Servo 5
      if (servo05SP[i] == servo05SP[i + 1]) {
      }
      if (servo05SP[i] > servo05SP[i + 1]) {
        for ( int j = servo05SP[i]; j >= servo05SP[i + 1]; j--) {
          servo05.write(j);
          delay(speedDelay);
        }
      }
      if (servo05SP[i] < servo05SP[i + 1]) {
        for ( int j = servo05SP[i]; j <= servo05SP[i + 1]; j++) {
          servo05.write(j);
          delay(speedDelay);
        }
      }

      // Servo 6
      if (servo06SP[i] == servo06SP[i + 1]) {
      }
      if (servo06SP[i] > servo06SP[i + 1]) {
        for ( int j = servo06SP[i]; j >= servo06SP[i + 1]; j--) {
          servo06.write(j);
          delay(speedDelay);
        }
      }
      if (servo06SP[i] < servo06SP[i + 1]) {
        for ( int j = servo06SP[i]; j <= servo06SP[i + 1]; j++) {
          servo06.write(j);
          delay(speedDelay);
        }
      }
    }
  }
}Code language: Arduino (arduino)

Espero que tenham gostado deste vídeo e aprendido algo novo. Sinta-se à vontade para fazer qualquer pergunta na seção de comentários abaixo e confira minha Coleção de projetos do Arduino.

Tutorial de controle de motor sem escova do Arduino | ESC | BLDC Rede sem fio Arduino com vários módulos NRF24L01