Primeros Pasos con la Placa Controladora de Servo de Bus / Adaptador de Servo de Bus XIAO

Esta wiki cubre dos productos relacionados: la Placa Controladora de Servo de Bus y el Adaptador de Servo de Bus XIAO.

La Placa Controladora de Servo de Bus no incluye un microcontrolador XIAO ESP32-C3 integrado, ni viene con una carcasa impresa en 3D. Está diseñada para funcionar como una placa de interfaz de servo de bus de propósito general, permitiéndote conectar y controlar servos a través de un controlador externo de tu elección.
El Adaptador de Servo de Bus XIAO, por otro lado, incluye el XIAO ESP32-C3 como controlador principal y viene con una carcasa impresa en 3D. Con esta versión, puedes controlar directamente servos de bus usando el XIAO integrado, convirtiéndolo en una solución más integrada y lista para usar en proyectos de robótica.

Por favor, consulta el resto de esta guía para obtener detalles sobre la configuración y uso de ambos productos.

Placa Controladora de Servo de Bus	Adaptador de Servo de Bus XIAO

Consigue Uno Ahora 🖱️	Consigue Uno Ahora 🖱️

Introducción

El Bus Servo Driver Board / XIAO Bus Servo Adapter es una solución de hardware compacta y potente de Seeed Studio, diseñada para controlar servos de bus serie para proyectos de robótica y automatización. Con soporte para comunicación UART, permite control preciso y retroalimentación de múltiples servos de la serie ST/SC, incluyendo la serie Feetech SCS (ver Sitio Web Oficial de la Serie Feetech SCS/STS/TTL). Esto lo hace ideal para aplicaciones como brazos robóticos, hexápodos, robots humanoides y robots con ruedas que requieren retroalimentación de ángulo y carga del servo.

Esta guía se enfoca en la configuración del hardware, conexiones físicas, especificaciones clave y configuraciones críticas de jumpers para ayudar a los usuarios a integrar la placa en sus proyectos de manera efectiva.

Advertencia de Seguridad

Siempre desconecte la alimentación antes de conectar o desconectar servos o cableado. Asegúrese de que el voltaje de entrada coincida con los requisitos del servo para evitar daños.

Descripción General del Hardware

Bus Servo Driver Board
XIAO Bus Servo Adapter

El Bus Servo Driver Board presenta varios puntos de conexión clave:

Entrada:

DC IN (5.5 * 2.1mm): Esta es la entrada de alimentación para la placa y los servos conectados. Conecte una fuente de alimentación de 5~12V aquí. Crucialmente, el voltaje de esta fuente de alimentación debe coincidir con los requisitos de voltaje de sus servos. Por ejemplo, los servos de la serie ST típicamente operan a 9V, mientras que los servos de la serie SC pueden requerir 12V.

Salida:

Interfaz del Servo: Este puerto dedicado es donde conecta sus servos de bus de la serie ST/SC. Asegúrese de que el conector esté correctamente alineado.

Interfaz de Control:

UART (RX/TX): Estos pines proporcionan comunicación serie para controlar los servos. El método de conexión y las configuraciones de jumper dependen de su dispositivo host. Vea los detalles a continuación.

Comenzando

Selección del modo de operación de la placa controladora (Solo para Bus Servo Driver Board)

tip

Para XIAO Bus Servo Adapter, no necesitas modificar ningún circuito para usar el XIAO ESP32-C3 incluido para controlar los servos, puedes omitir esta parte directamente.

La Bus Servo Driver Board ofrece dos métodos de conexión principales: conexión UART directa y conexión USB a través de un adaptador USB-a-UART. La configuración correcta del jumper es esencial para el funcionamiento adecuado.

Conexión UART (para MCUs, XIAO, ESP32, etc.)

Este método se usa cuando se conecta directamente a los pines UART de un microcontrolador (MCU) como un ESP32, Arduino, Seeed Studio XIAO, o una computadora de placa única.

Cableado:
- Conecta el pin RX en la Driver Board al pin TX (D7) en tu dispositivo host.
- Conecta el pin TX en la Driver Board al pin RX (D6) en tu dispositivo host.
- Para dispositivos como el Seeed Studio XIAO, puedes conectar directamente el XIAO en los conectores proporcionados, asegurando la alineación correcta de los pines. Esto elimina la necesidad de cables Dupont separados para la conexión UART.
Configuración del Jumper (Crítico):
- Usa una tapa de jumper de 2.54mm para cortocircuitar el pin de 2 pines en la parte frontal de la placa. (Está cortocircuitado por defecto)
Alimentación del Host: Tu dispositivo host (ej. Raspberry Pi Zero, ESP32, XIAO) requerirá su propia fuente de alimentación separada.

Conexión USB

Este método se usa cuando se conecta a una computadora o computadora de placa única con un puerto USB (ej. una PC o Raspberry Pi 4B). Simplemente conectas la placa de control a la computadora usando un cable USB.

Cableado:
- Simplemente conecta la placa de control a tu computadora usando un cable USB.
Configuración del Jumper (Crítico):
- Paso 1. Localiza el jumper de soldadura en la parte posterior de la placa. Para comunicación USB, debes asegurar que las dos almohadillas estén conectadas (hay un puente de soldadura entre ellas).
- Almohadillas del lado posterior para versión 1:
- Almohadillas del lado posterior para versión 2:
- Paso 2. Usa una tapa de jumper de 2.54mm para cortocircuitar el pin de 2 pines en la parte frontal de la placa. (Está cortocircuitado por defecto)

Componentes Requeridos (Antes de Comenzar)

Antes de conectar cualquier cosa, asegúrate de tener lo siguiente:

Bus Servo Driver Board / XIAO Bus Servo Adapter
Servos bus compatibles de serie ST/SC: ver Sitio Web Oficial de Feetech SCS/STS/TTL Series.
Fuente de Alimentación de 5~12V: Una batería o adaptador de corriente. El voltaje debe coincidir con las especificaciones de tu servo.
Dispositivo Host:
- Para UART Directo: Un dispositivo con capacidad UART como un Raspberry Pi, Arduino, ESP32, o Seeed Studio XIAO.
- Para USB: Una computadora (PC, Mac, Linux) o una computadora de placa única como un Raspberry Pi 4B, más un adaptador USB-a-UART.

note

Para XIAO Bus Servo Adapter, XIAO ESP32-C3 está integrado, por lo que no hay necesidad de preparar un dispositivo host.

Cables/Adaptadores de Conexión: Cables jumper (cables Dupont) si usas UART directo (excepto cuando uses XIAO con conexión directa de conectores). Un adaptador USB-a-UART si usas el método de conexión USB.

caution

Si usas servos de serie SC, confirma que la fuente de alimentación coincida con sus requerimientos de voltaje. La etiqueta de entrada DC de la placa está adaptada para servos de serie ST pero también soporta voltajes de serie SC. Configuraciones incorrectas del jumper impedirán la comunicación con la placa controladora.

Control de Servos vía USB

Esta sección describe cómo controlar múltiples servos de bus a través de la Placa Controladora de Servos de Bus usando una conexión USB.

Descripción General del Principio

La Placa Controladora de Servos de Bus funciona recibiendo comandos serie (UART) desde tu dispositivo host (como una PC, Raspberry Pi, o microcontrolador) vía USB. Estos comandos son luego retransmitidos a los servos de bus conectados. Al enviar los comandos de protocolo serie apropiados, puedes controlar la posición, velocidad y otros parámetros de cada servo individualmente.

La placa en sí no interpreta ni genera señales de control de servo de forma autónoma; en su lugar, actúa como un puente transparente entre tu host y los servos. Esto significa que eres responsable de enviar los paquetes de comando correctos de acuerdo al protocolo de comunicación de tu servo.

Ejemplo de Referencia

Para un ejemplo práctico de cómo enviar comandos a servos de bus Feetech (series ST/SC/STS/TTL), puedes consultar el siguiente ejemplo en Python:
lerobot/common/robot_devices/motors/feetech.py en GitHub

Este ejemplo demuestra cómo construir y enviar paquetes serie para controlar servos Feetech. Puedes adaptar el código a tu propia plataforma host y lenguaje de programación según sea necesario.

Nota:

El formato de comando específico y el protocolo pueden variar dependiendo del modelo de tu servo.

Por favor consulta la documentación oficial de tu servo para el protocolo serie correcto y la estructura de comandos.

Necesitarás escribir o adaptar un programa controlador que coincida con los requisitos de tu servo.

Para más detalles sobre el protocolo de las series Feetech SCS/STS/TTL, consulta la documentación oficial de Feetech.

Control de Servos vía XIAO

A continuación, describimos cómo enviar señales para controlar el movimiento del servo a través de XIAO y cómo usar la biblioteca.

Descripción General de la Biblioteca Arduino

tip

Si esta es tu primera vez usando Arduino, te recomendamos encarecidamente que consultes Comenzando con Arduino.

Descargar la Biblioteca

Función

Antes de comenzar a desarrollar un sketch, veamos las funciones disponibles de la biblioteca.

SMS_STS(uint8_t id) —— Crear un objeto servo con el ID especificado.
Parámetros: uint8_t id (ID del servo)
Salida: ninguna
void WritePos(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed) —— Establecer la posición objetivo, tiempo y velocidad para el servo.
Parámetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed
Salida: ninguna
void RegWritePos(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed) —— Establecer la posición objetivo, tiempo y velocidad para el servo, pero ejecutar más tarde con el comando Action.
Parámetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed
Salida: ninguna
void RegWriteAction() —— Ejecutar todos los comandos RegWritePos registrados.
Parámetros: ninguno
Salida: ninguna
void WriteSpe(uint8_t id, int16_t Speed) —— Establecer la velocidad de rotación para el servo.
Parámetros: uint8_t id, int16_t Speed
Salida: ninguna
void WritePosEx(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC) —— Establecer posición, tiempo, velocidad y aceleración.
Parámetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC
Salida: ninguna
void RegWritePosEx(uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC) —— Registrar posición, tiempo, velocidad y aceleración, ejecutar más tarde.
Parámetros: uint8_t id, int16_t Position, uint16_t Time, uint16_t Speed, uint8_t ACC
Salida: ninguna
void RegWriteActionEx() —— Ejecutar todos los comandos RegWritePosEx registrados.
Parámetros: ninguno
Salida: ninguna
int16_t ReadPos(uint8_t id) —— Leer la posición actual del servo.
Parámetros: uint8_t id
Salida: int16_t (posición)
int16_t ReadSpeed(uint8_t id) —— Leer la velocidad actual del servo.
Parámetros: uint8_t id
Salida: int16_t (velocidad)
int16_t ReadLoad(uint8_t id) —— Leer la carga actual del servo.
Parámetros: uint8_t id
Salida: int16_t (carga)
int16_t ReadVoltage(uint8_t id) —— Leer el voltaje actual del servo.
Parámetros: uint8_t id
Salida: int16_t (voltaje)
int16_t ReadTemper(uint8_t id) —— Leer la temperatura actual del servo.
Parámetros: uint8_t id
Salida: int16_t (temperatura)
int16_t ReadMove(uint8_t id) —— Verificar si el servo se está moviendo.
Parámetros: uint8_t id
Salida: int16_t (1: moviéndose, 0: detenido)
int16_t ReadCurrent(uint8_t id) —— Leer la corriente (corriente eléctrica) del servo.
Parámetros: uint8_t id
Salida: int16_t (corriente)
void SetID(uint8_t id, uint8_t newid) —— Establecer un nuevo ID para el servo.
Parámetros: uint8_t id, uint8_t newid
Salida: ninguna
void Load(uint8_t id) —— Habilitar el torque del servo.
Parámetros: uint8_t id
Salida: ninguna
void Unload(uint8_t id) —— Deshabilitar el torque del servo.
Parámetros: uint8_t id
Salida: ninguna
int16_t ReadTorque(uint8_t id) —— Leer el estado del torque del servo.
Parámetros: uint8_t id
Salida: int16_t (1: habilitado, 0: deshabilitado)
void LEDAlarm(uint8_t id, uint8_t enable) —— Configurar el estado de alarma LED.
Parámetros: uint8_t id, uint8_t enable
Salida: ninguna
void Reset(uint8_t id) —— Restablecer el servo a la configuración de fábrica.
Parámetros: uint8_t id
Salida: ninguna
void LockEprom(uint8_t id) —— Bloquear la EEPROM del servo.
Parámetros: uint8_t id
Salida: ninguna
void UnlockEprom(uint8_t id) —— Desbloquear la EEPROM del servo.
Parámetros: uint8_t id
Salida: ninguna

Ejemplo XIAO

Ahora que tenemos nuestra biblioteca instalada y entendemos las funciones básicas, ejecutemos algunos ejemplos para nuestro 产品名称 para ver cómo se comporta.

Paso 1. Iniciar la aplicación Arduino.

Descargar Arduino IDE

Paso 2. Seleccionar el modelo de tu placa de desarrollo y añadirla al Arduino IDE.

Para usar Seeed Studio XIAO ESP32-C3 para las rutinas posteriores, por favor consulta este tutorial para completar la adición.

Paso 3. Completar el cableado como se muestra. Si necesitas conectar múltiples servos, puedes usar los cables que vienen con los servos para completar la conexión.

Controlar múltiples 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 ejemplo demuestra cómo controlar múltiples servos de bus de la serie SCS de Feetech usando el XIAO y la biblioteca SCServo. El código inicializa dos servos, los calibra y permite al usuario ajustar sus posiciones de forma interactiva mediante comandos serie. Cuando envías 'j' o 'k' a través del monitor serie, el código disminuirá o aumentará el ángulo de todos los servos conectados, respectivamente. La posición actual de cada servo se rastrea y actualiza en consecuencia, y las nuevas posiciones se envían a los servos usando la función SyncWritePosEx.

Cómo personalizar para tu propio proyecto:

Número de Servos: Cambia el valor de Servo_Num y actualiza los arrays ID, Speed, ACC y Pos para que coincidan con el número e IDs de tus servos. IDs de Servo: Modifica el array ID para que coincida con los IDs de tus servos conectados.
Velocidad y Aceleración: Ajusta los arrays Speed y ACC para establecer diferentes velocidades y aceleraciones para cada servo.
Pines Serie: Si usas diferentes pines para UART, actualiza las definiciones S_RXD y S_TXD.
Lógica de Movimiento: Puedes cambiar la lógica en la función loop() para implementar comportamientos más complejos o específicos del proyecto, como responder a diferentes comandos serie, agregar retroalimentación de sensores o integrar con otro hardware.
Posición Inicial: Establece los valores iniciales en el array Pos para definir las posiciones de inicio de tus servos.

FAQs

tip

Se recomienda leer estas FAQs antes de comenzar tu proyecto. Abordan preguntas comunes y problemas potenciales.

¿Qué pasa si el voltaje de la fuente de alimentación no coincide con mi servo?

La placa y el servo pueden funcionar mal o sufrir daños. Siempre haz coincidir el voltaje de entrada con los requisitos de tu servo.

¿Puedo conectar múltiples servos a la vez?

Sí, se admiten múltiples servos, pero asegúrate de que tu fuente de alimentación pueda manejar el consumo de corriente combinado.

Recursos

[PDF] Esquemático de la Placa Controladora de Servo de Bus

Soporte Técnico y Discusión de Productos

¡Gracias por elegir nuestros productos! Estamos aquí para brindarte diferentes tipos de soporte para asegurar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para atender diferentes preferencias y necesidades.

Introducción​

Descripción General del Hardware​

Comenzando​

Selección del modo de operación de la placa controladora (Solo para Bus Servo Driver Board)​

Conexión UART (para MCUs, XIAO, ESP32, etc.)​

Conexión USB​

Componentes Requeridos (Antes de Comenzar)​

Control de Servos vía USB​

Descripción General del Principio​

Ejemplo de Referencia​

Control de Servos vía XIAO​

Descripción General de la Biblioteca Arduino​

Función​

Ejemplo XIAO​

Controlar múltiples servos​

FAQs​

Recursos​

Soporte Técnico y Discusión de Productos​