Introdução à Bus Servo Driver Board / XIAO Bus Servo Adapter

Este wiki abrange dois produtos relacionados: a Bus Servo Driver Board e o XIAO Bus Servo Adapter.

A Bus Servo Driver Board não inclui um microcontrolador XIAO ESP32-C3 onboard, nem vem com um gabinete impresso em 3D. Ela foi projetada para funcionar como uma placa de interface de servo de barramento de uso geral, permitindo que você conecte e controle servos por meio de um controlador externo de sua escolha.
O XIAO Bus Servo Adapter, por outro lado, inclui o XIAO ESP32-C3 como controlador principal e vem com um case impresso em 3D. Com esta versão, você pode controlar diretamente servos de barramento usando o XIAO onboard, tornando-o uma solução mais integrada e pronta para uso em projetos de robótica.

Consulte o restante deste guia para obter detalhes sobre configuração e uso de ambos os produtos.

Bus Servo Driver Board	XIAO Bus Servo Adapter

Adquira agora 🖱️	Adquira agora 🖱️

Introdução

A Bus Servo Driver Board / XIAO Bus Servo Adapter é uma solução de hardware compacta e poderosa da Seeed Studio, projetada para acionar servos de barramento serial para projetos de robótica e automação. Com suporte à comunicação UART, ela permite controle preciso e feedback de múltiplos servos da série ST/SC, incluindo a série Feetech SCS (veja o site oficial da Série Feetech SCS/STS/TTL). Isso a torna ideal para aplicações como braços robóticos, hexápodes, robôs humanóides e robôs com rodas que exigem feedback de ângulo e carga do servo.

Este guia se concentra na configuração de hardware, conexões físicas, principais especificações e configurações críticas de jumper para ajudar os usuários a integrar a placa em seus projetos de forma eficaz.

Aviso de Segurança

Sempre desconecte a alimentação antes de conectar ou desconectar servos ou fiação. Certifique-se de que a tensão de entrada corresponda aos requisitos do servo para evitar danos.

Visão Geral de Hardware

Bus Servo Driver Board
XIAO Bus Servo Adapter

A Bus Servo Driver Board possui vários pontos principais de conexão:

Entrada:

DC IN (5.5 * 2.1mm): Esta é a entrada de alimentação para a placa e para os servos conectados. Conecte aqui uma fonte de alimentação de 5~12V. É crucial que a tensão dessa fonte corresponda aos requisitos de tensão dos seus servos. Por exemplo, servos da série ST normalmente operam em 9V, enquanto servos da série SC podem exigir 12V.

Saída:

Interface de Servo: Esta porta dedicada é onde você conecta seus servos de barramento das séries ST/SC. Certifique-se de que o conector esteja corretamente alinhado.

Interface de Controle:

UART (RX/TX): Estes pinos fornecem comunicação serial para controlar os servos. O método de conexão e as configurações de jumper dependem do seu dispositivo host. Veja abaixo para detalhes.

Primeiros Passos

Selecionando o modo de operação da placa controladora (Somente para Bus Servo Driver Board)

dica

Para o XIAO Bus Servo Adapter, você não precisa modificar nenhum circuito para usar o XIAO ESP32-C3 incluso para controlar os servos; você pode pular diretamente esta parte.

A Bus Servo Driver Board oferece dois métodos principais de conexão: conexão UART direta e conexão USB por meio de um adaptador USB-para-UART. A configuração correta do jumper é essencial para o funcionamento adequado.

Conexão UART (para MCUs, XIAO, ESP32, etc.)

Este método é usado ao conectar diretamente aos pinos UART de um microcontrolador (MCU), como um ESP32, Arduino, Seeed Studio XIAO ou um computador de placa única.

Fiação:
- Conecte o pino RX da Driver Board ao pino TX (D7) do seu dispositivo host.
- Conecte o pino TX da Driver Board ao pino RX (D6) do seu dispositivo host.
- Para dispositivos como o Seeed Studio XIAO, você pode conectar o XIAO diretamente aos headers fornecidos, garantindo o alinhamento correto dos pinos. Isso elimina a necessidade de fios Dupont separados para a conexão UART.
Configuração de Jumper (Crítica):
- Use um jumper de 2,54mm para curto-circuitar o pino de 2 pinos na parte frontal da placa. (Ele vem curto-circuitado por padrão)
Alimentando o Host: Seu dispositivo host (por exemplo, Raspberry Pi Zero, ESP32, XIAO) exigirá sua própria fonte de alimentação separada.

Conexão USB

Este método é usado ao conectar a um computador ou a um computador de placa única com uma porta USB (por exemplo, um PC ou Raspberry Pi 4B). Você simplesmente conecta a placa controladora ao computador usando um cabo USB.

Fiação:
- Basta conectar a placa controladora ao seu computador usando um cabo USB.
Configuração de Jumper (Crítica):
- Etapa 1. Localize o jumper de solda na parte traseira da placa. Para comunicação USB, você deve garantir que as duas ilhas estejam conectadas (existe uma ponte de solda entre elas).
- Ilhas traseiras para a versão 1:
- Ilhas traseiras para a versão 2:
- Etapa 2. Use um jumper de 2,54mm para curto-circuitar o pino de 2 pinos na parte frontal da placa. (Ele vem curto-circuitado por padrão)

Componentes Necessários (Antes de Começar)

Antes de conectar qualquer coisa, certifique-se de ter o seguinte:

Bus Servo Driver Board / XIAO Bus Servo Adapter
Servos de barramento compatíveis das séries ST/SC: veja o site oficial da Série Feetech SCS/STS/TTL.
Fonte de Alimentação de 5~12V: Uma bateria ou adaptador de energia. A tensão deve corresponder às especificações do seu servo.
Dispositivo Host:
- Para UART Direto: Um dispositivo com capacidade UART como um Raspberry Pi, Arduino, ESP32 ou Seeed Studio XIAO.
- Para USB: Um computador (PC, Mac, Linux) ou um computador de placa única como um Raspberry Pi 4B, mais um adaptador USB-para-UART.

nota

Para o XIAO Bus Servo Adapter, o XIAO ESP32-C3 é integrado, portanto não há necessidade de preparar um dispositivo host.

Cabos/Adaptadores de Conexão: Fios jumper (fios Dupont) se estiver usando UART direto (exceto ao usar XIAO com conexão direta via header). Um adaptador USB-para-UART se estiver usando o método de conexão USB.

cuidado

Se estiver usando servos da série SC, confirme se a fonte de alimentação corresponde aos requisitos de tensão deles. O rótulo de entrada CC da placa é voltado para servos da série ST, mas também suporta tensões da série SC. Configurações incorretas de jumper impedirão a comunicação com a placa controladora.

Controlando Servos via USB

Esta seção descreve como controlar vários servos de barramento por meio da Bus Servo Driver Board usando uma conexão USB.

Visão Geral do Princípio

A Bus Servo Driver Board funciona recebendo comandos seriais (UART) do seu dispositivo host (como um PC, Raspberry Pi ou microcontrolador) via USB. Esses comandos são então retransmitidos para os servos de barramento conectados. Enviando os comandos apropriados do protocolo serial, você pode controlar posição, velocidade e outros parâmetros de cada servo individualmente.

A própria placa não interpreta nem gera sinais de controle de servo de forma autônoma; em vez disso, atua como uma ponte transparente entre o seu host e os servos. Isso significa que você é responsável por enviar os pacotes de comando corretos de acordo com o protocolo de comunicação do seu servo.

Referência de Exemplo

Para um exemplo prático de como enviar comandos para servos de barramento Feetech (séries ST/SC/STS/TTL), você pode consultar o seguinte exemplo em Python:
lerobot/common/robot_devices/motors/feetech.py on GitHub

Este exemplo demonstra como construir e enviar pacotes seriais para controlar servos Feetech. Você pode adaptar o código para sua própria plataforma host e linguagem de programação, conforme necessário.

Observação:

O formato específico de comando e o protocolo podem variar dependendo do modelo do seu servo.

Consulte a documentação oficial do seu servo para obter o protocolo serial correto e a estrutura de comandos.

Você precisará escrever ou adaptar um programa de driver que atenda aos requisitos do seu servo.

Para mais detalhes sobre o protocolo das séries Feetech SCS/STS/TTL, consulte a documentação oficial da Feetech.

Controlando Servos via XIAO

Em seguida, descrevemos como enviar sinais para controlar o movimento do servo por meio do XIAO e como usar a biblioteca.

Visão Geral da Biblioteca Arduino

dica

Se esta é a sua primeira vez usando Arduino, recomendamos fortemente que você consulte Primeiros Passos com Arduino.

Baixar a Biblioteca

Função

Antes de começarmos a desenvolver um sketch, vamos ver as funções disponíveis da biblioteca.

SMS_STS(uint8_t id) —— Cria um objeto de servo com o ID especificado.
Parâmetros: uint8_t id (ID do servo)
Saída: nenhuma
void WritePos(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed) —— Define a posição alvo, o tempo e a velocidade para o servo.
Parâmetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed
Saída: nenhuma
void RegWritePos(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed) —— Define a posição alvo, o tempo e a velocidade para o servo, mas executa depois com o comando Action.
Parâmetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed
Saída: nenhuma
void RegWriteAction() —— Executa todos os comandos RegWritePos registrados.
Parâmetros: nenhum
Saída: nenhuma
void WriteSpe(uint8_t id, int16_t Speed) —— Define a velocidade de rotação do servo.
Parâmetros: uint8_t id, int16_t Speed
Saída: nenhuma
void WritePosEx(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC) —— Define posição, tempo, velocidade e aceleração.
Parâmetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC
Saída: nenhuma
void RegWritePosEx(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC) —— Registra posição, tempo, velocidade e aceleração, para executar depois.
Parâmetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC
Saída: nenhuma
void RegWriteActionEx() —— Executa todos os comandos RegWritePosEx registrados.
Parâmetros: nenhum
Saída: nenhuma
int16_t ReadPos(uint8_t id) —— Lê a posição atual do servo.
Parâmetros: uint8_t id
Saída: int16_t (posição)
int16_t ReadSpeed(uint8_t id) —— Lê a velocidade atual do servo.
Parâmetros: uint8_t id
Saída: int16_t (velocidade)
int16_t ReadLoad(uint8_t id) —— Lê a carga atual do servo.
Parâmetros: uint8_t id
Saída: int16_t (carga)
int16_t ReadVoltage(uint8_t id) —— Lê a tensão atual do servo.
Parâmetros: uint8_t id
Saída: int16_t (tensão)
int16_t ReadTemper(uint8_t id) —— Lê a temperatura atual do servo.
Parâmetros: uint8_t id
Saída: int16_t (temperatura)
int16_t ReadMove(uint8_t id) —— Verifica se o servo está se movendo.
Parâmetros: uint8_t id
Saída: int16_t (1: em movimento, 0: parado)
int16_t ReadCurrent(uint8_t id) —— Lê a corrente elétrica do servo.
Parâmetros: uint8_t id
Saída: int16_t (corrente)
void SetID(uint8_t id, uint8_t newid) —— Define um novo ID para o servo.
Parâmetros: uint8_t id, uint8_t newid
Saída: nenhuma
void Load(uint8_t id) —— Habilita o torque do servo.
Parâmetros: uint8_t id
Saída: nenhuma
void Unload(uint8_t id) —— Desabilita o torque do servo.
Parâmetros: uint8_t id
Saída: nenhuma
int16_t ReadTorque(uint8_t id) —— Lê o status de torque do servo.
Parâmetros: uint8_t id
Saída: int16_t (1: habilitado, 0: desabilitado)
void LEDAlarm(uint8_t id, uint8_t enable) —— Define o status de alarme do LED.
Parâmetros: uint8_t id, uint8_t enable
Saída: nenhuma
void Reset(uint8_t id) —— Restaura o servo para as configurações de fábrica.
Parâmetros: uint8_t id
Saída: nenhuma
void LockEprom(uint8_t id) —— Bloqueia a EEPROM do servo.
Parâmetros: uint8_t id
Saída: nenhuma
void UnlockEprom(uint8_t id) —— Desbloqueia a EEPROM do servo.
Parâmetros: uint8_t id
Saída: nenhuma

Exemplo com XIAO

Agora que temos nossa biblioteca instalada e entendemos as funções básicas, vamos executar alguns exemplos para o nosso 产品名称 e ver como ele se comporta.

Passo 1. Inicie o aplicativo Arduino.

Baixar Arduino IDE

Passo 2. Selecione o modelo da sua placa de desenvolvimento e adicione-o ao Arduino IDE.

Para usar o Seeed Studio XIAO ESP32-C3 nas rotinas posteriores, consulte este tutorial para concluir a adição.

Passo 3. Complete a fiação como mostrado. Se você precisar conectar vários servos, pode usar os cabos que vêm com os servos para completar a conexão.

Controlar vários servos

#include <SCServo.h>

// Define the correct serial port for your target board
#if defined(CONFIG_IDF_TARGET_ESP32C3) || defined(CONFIG_IDF_TARGET_ESP32C6) || defined(CONFIG_IDF_TARGET_ESP32S3)
#define COMSerial Serial0
#else
#define COMSerial Serial1
#endif

// Define RX/TX pins for the servo bus (for reference)
// Note: On ESP32, pins are usually specified in COMSerial.begin().
// For example: COMSerial.begin(1000000, SERIAL_8N1, S_RXD, S_TXD);
// If your board uses the default pins for Serial1, no extra specification is needed.
#define S_RXD D7
#define S_TXD D6

#define SERVO_NUM 2 // Number of servos

SMS_STS st; // Servo control object

// --- Servo Configuration ---
byte ID[SERVO_NUM] = {1, 2};                // IDs of the servos
u16 Speed[SERVO_NUM] = {1500, 1500};         // Set a medium speed for the servos
byte ACC[SERVO_NUM] = {50, 50};             // Set a medium acceleration for the servos
s16 Pos[SERVO_NUM] = {2048, 2048};           // Servo position array, initialized to the midpoint (2048)

void setup()
{
  // Start the main serial port for debugging and receiving commands
  Serial.begin(115200);
  // Wait a moment for the Serial Monitor to connect
  delay(2000); 
  Serial.println("--- Servo Control Program Start ---");

  // Start the serial port for controlling the servos
  COMSerial.begin(1000000, SERIAL_8N1);
  st.pSerial = &COMSerial; // Associate the control object with the serial port

  Serial.println("Checking servo connection status...");
  for (int i = 0; i < SERVO_NUM; i++) {
    if (st.Ping(ID[i]) != -1) {
      Serial.print("Servo with ID ");
      Serial.print(ID[i]);
      Serial.println(" is connected.");
    } else {
      Serial.print("Error: Servo with ID ");
      Serial.print(ID[i]);
      Serial.println(" is not responding!");
    }
  }

  // --- Power-on Self-Test ---
  // This section makes the servos move automatically on power-up to confirm they are working correctly.
  Serial.println("\nExecuting power-on self-test movement...");

  // 1. Move to position 1024
  Serial.println("Moving to position 1024...");
  for(int i=0; i<SERVO_NUM; i++) {
    Pos[i] = 1024;
  }
  st.SyncWritePosEx(ID, SERVO_NUM, Pos, Speed, ACC);
  delay(2000); // Wait for the movement to complete

  // 2. Move to position 3072
  Serial.println("Moving to position 3072...");
  for(int i=0; i<SERVO_NUM; i++) {
    Pos[i] = 3072;
  }
  st.SyncWritePosEx(ID, SERVO_NUM, Pos, Speed, ACC);
  delay(2000); // Wait for the movement to complete

  // 3. Return to center position (2048) to prepare for user commands
  Serial.println("Returning to center position (2048)...");
  for(int i=0; i<SERVO_NUM; i++) {
    Pos[i] = 2048;
  }
  st.SyncWritePosEx(ID, SERVO_NUM, Pos, Speed, ACC);
  delay(1500);

  Serial.println("\n--- Initialization Complete ---");
  Serial.println("Enter 'j' to decrease the angle, or 'k' to increase it.");
  Serial.println("-----------------------------------");
}

void loop()
{
  // Check if the user has sent a command via the Serial Monitor
  if (Serial.available()) {
    String input = Serial.readString();
    input.trim(); // Remove extra spaces or newlines

    bool shouldMove = false; // Flag to indicate if a valid command was received

    if (input.startsWith("j")) {
      Serial.println("Received command: 'j'. Decreasing angle.");
      for (int i = 0; i < SERVO_NUM; i++) {
        Pos[i] -= 512; // Move a small step for easy observation
        if (Pos[i] < 0) {
          Pos[i] = 0; // Prevent going below the minimum range
        }
      }
      shouldMove = true;
    } else if (input.startsWith("k")) {
      Serial.println("Received command: 'k'. Increasing angle.");
      for (int i = 0; i < SERVO_NUM; i++) {
        Pos[i] += 512; // Move a small step
        if (Pos[i] > 4095) {
          Pos[i] = 4095; // Prevent going above the maximum range
        }
      }
      shouldMove = true;
    } else {
      Serial.print("Unknown command: '");
      Serial.print(input);
      Serial.println("'. Please enter 'j' or 'k'.");
    }

    // If a valid command was received, send the new positions to the servos
    if (shouldMove) {
      Serial.print("Moving servos to new positions: [");
      for(int i = 0; i < SERVO_NUM; i++){
        Serial.print(Pos[i]);
        if(i < SERVO_NUM - 1) Serial.print(", ");
      }
      Serial.println("]");

      st.SyncWritePosEx(ID, SERVO_NUM, Pos, Speed, ACC);
    }
  }
}

Este exemplo demonstra como controlar vários servos de barramento Feetech da série SCS usando o XIAO e a biblioteca SCServo. O código inicializa dois servos, calibra-os e permite que você ajuste suas posições interativamente via comandos seriais. Quando você envia 'j' ou 'k' pelo monitor serial, o código diminui ou aumenta o ângulo de todos os servos conectados, respectivamente. A posição atual de cada servo é rastreada e atualizada de acordo, e as novas posições são enviadas aos servos usando a função SyncWritePosEx.

Como personalizar para o seu próprio projeto:

Número de Servos: Altere o valor de Servo_Num e atualize os arrays de ID, Speed, ACC e Pos para corresponder ao número e aos IDs dos seus servos. IDs dos servos: Modifique o array de ID para corresponder aos IDs dos seus servos conectados.
Velocidade e Aceleração: Ajuste os arrays Speed e ACC para definir diferentes velocidades e acelerações para cada servo.
Pinos Seriais: Se você usar pinos diferentes para UART, atualize as definições de S_RXD e S_TXD.
Lógica de Movimento: Você pode alterar a lógica na função loop() para implementar comportamentos mais complexos ou específicos do projeto, como responder a diferentes comandos seriais, adicionar feedback de sensores ou integrar com outros hardwares.
Posição Inicial: Defina os valores iniciais no array Pos para definir as posições iniciais dos seus servos.

FAQs

dica

Recomenda-se ler estas FAQs antes de iniciar o seu projeto. Elas abordam dúvidas comuns e possíveis problemas.

E se a tensão de alimentação não corresponder ao meu servo?

A placa e o servo podem funcionar incorretamente ou sofrer danos. Sempre combine a tensão de entrada com os requisitos do seu servo.

Posso conectar vários servos ao mesmo tempo?

Sim, vários servos são suportados, mas certifique-se de que sua fonte de alimentação possa suportar a corrente total consumida.

Recursos

[PDF] Esquemático da Placa Controladora de Servo de Barramento
[STL] Carcaça superior do Adaptador de Servo de Barramento XIAO
[STL] Carcaça inferior do Adaptador de Servo de Barramento XIAO

Suporte Técnico & Discussão de Produtos

Obrigado por escolher nossos produtos! Estamos aqui para lhe fornecer diferentes tipos de suporte para garantir que sua experiência com nossos produtos seja a mais tranquila possível. Oferecemos vários canais de comunicação para atender a diferentes preferências e necessidades.

Introdução​

Visão Geral de Hardware​

Primeiros Passos​

Selecionando o modo de operação da placa controladora (Somente para Bus Servo Driver Board)​

Conexão UART (para MCUs, XIAO, ESP32, etc.)​

Conexão USB​

Componentes Necessários (Antes de Começar)​

Controlando Servos via USB​

Visão Geral do Princípio​

Referência de Exemplo​

Controlando Servos via XIAO​

Visão Geral da Biblioteca Arduino​

Função​

Exemplo com XIAO​

Controlar vários servos​

FAQs​

Recursos​

Suporte Técnico & Discussão de Produtos​

Introdução

Visão Geral de Hardware

Primeiros Passos

Selecionando o modo de operação da placa controladora (Somente para Bus Servo Driver Board)

Conexão UART (para MCUs, XIAO, ESP32, etc.)

Conexão USB

Componentes Necessários (Antes de Começar)

Controlando Servos via USB

Visão Geral do Princípio

Referência de Exemplo

Controlando Servos via XIAO

Visão Geral da Biblioteca Arduino

Função

Exemplo com XIAO

Controlar vários servos

FAQs

Recursos

Suporte Técnico & Discussão de Produtos