Hasta 32 de servos en Arduino con el controlador USC-32

¿Qué es un controlador de servos USC-32?

El USC-32 (equivalentemente SSC-32) es un controlador de servos avanzado de 32 canales que podemos conectar a un procesador como Arduino para controlar hasta 32 servos de forma simultánea.

El USC-32 incorpora un avanzado procesador ARM de 32 bits. La comunicación se realiza a través de UART, lo que permite emplear USB, Bluetooth o Wifi. El baud rate es reconocido automáticamente entre 9600,19200,28400,57600,115200,128000.

El control del USC-32 se realiza mediante comandos que indican el servo a controlar, el ángulo al que deseamos que se desplace, y el tiempo que debe durar el movimiento. De esta forma podemos mover los servos simultáneamente sin requerir más acciones ni supervisión de Arduino, librando de una gran carga de procesador.

La resolución de la señal de control de posición de los servos es de 1us, superior a la que podemos encontrar en la mayoría de controladores. Además, el USC-32 dispone de una memoria ROM de 512K que puede emplearse para almacenar comandos o movimientos programados.

El USC-32 es un controlador de servos avanzado que facilita mucho el manejo de servos, especialmente en el caso de robots complejos como brazos robóticos, cuadrúpedos, hexápodos, o robots bípedos.

Precio

El USC-32 es un dispositivo de altas prestaciones, cómodo y sencillo de emplear, pero a cambio tiene un precio bastante elevado. Podemos encontrarlo por 20€, buscando en vendedores internacionales de eBay o AliExpress.

Este precio es muy superior al resto de controladores de servo, e incluso superior a otras alternativas como hacer nuestro propio controlador con un Arduino Mega, un STM32, un ESP8266, o incluso mini PC con Linux como el Orange Pi.

Por tanto, deberemos sopesar si preferimos la sencillez de uso y montaje de usar el USC-32, o si preferimos montar nuestro propio controlador con una alternativa más barata.

Esquema de conexión

La conexión del módulo es sencilla, ya que como comentamos es uno de sus puntos fuertes. Simplemente vamos a necesitar conectar los pines RX y TX del puerto serie de Arduino. La única complicación será elegir la mejor forma de alimentar el conjunto.

El USB-32 necesita dos entradas de corriente:

• Una alimenta la lógica del módulo a través de un regulador de tensión, y admite tensiones entre 6.5V y 12V.
• La otra alimenta directamente los servos y, aunque admite tensiones entre 0V y 12V, el rango real será el que admitan nuestros servos, que en general es entre 5V y 6V.

Idealmente deberíamos tener dos fuentes, una de más de 6.5V que alimente la lógica del sistema, que apenas soportara intensidad. Otra fuente de entre unos 6V, que será la que realmente soporte la intensidad y el consumo de los servos.

Ambas fuentes serían independientes para que el consumo de los servos no introduzca ruido en la línea lógica que pueda provocar que la lógica se reinicie. Pero eso significa usar dos baterías, y de distinto voltaje, lo cual no resulta práctico.

Una opción es usar una única fuente de unos 6.5V-7V para ambas alimentaciones. Es forzar un poco los servos, pero en la mayoría de los casos no encontraremos problemas.

Además podemos emplear esta misma fuente para alimentar Arduino. Aunque normalmente resulta más conveniente alimentar Arduino desde el propio USC-32 a través del pin de 5V de Arduino, usando el regulador de tensión del USC-32.

En este caso, la conexión del USC-32 sería la siguiente.

Que vista desde Arduino queda.

Ejemplos de código

El controlador USC-32 recibe comandos a través del puerto serie. Estos comandos tienen la forma

[channel] P[pw] ... #[channel] P[pw] T[time] \n\r

Siendo,

• [channel] = Número de servo (1 a 32)
• [pw] = Ancho del pulso = posición deseada (rango de 500 a 2500, en us)
• [time] = Tiempo para mover todos los servos del comando (en ms)
• \n\r = Salto de línea

Un ejemplo de comando sería el siguiente,

#11 P2000 #30 P2500 T1500 \n\r

Que movería el servo 11 a 2000us y el 30 a 2500us en un rango de 1500ms. Los servos 11 y 30 llegarían al ángulo deseado al mismo tiempo. La velocidad dependería de la posición de la que partiera cada servo.

Para que sea más sencillo manejar el USC-32 nos construimos una función que envíe los comandos necesarios por el puerto serie. El siguiente ejemplo mueve los 32 servos desde la posición mínima del servo a la máxima, y en sentido contrario.

uint8_t ServoMinMs = 500; // ancho de pulso en ms para pocicion 0°
uint8_t ServoMaxMs = 2500; // ancho de pulso en ms para la pocicion 180°

void setup()
{
  Serial.begin(9600);
}

void loop() 
{
  for (uint8_t servo = 0; servo < 32; servo++)
  {
    for (uint16_t servoPos = ServoMinMs; servoPos < ServoMaxMs; servoPos++)
    {
      moveServo(servo, servoPos, 500);
    }
  }
  delay(750
  for (uint8_t servo = 0; servo < 32; servo++)
  {
    for (uint16_t servoPos = ServoMaxMs; servoPos > ServoMinMs; servoPos--)
    {
      moveServo(servo, servoPos, 500);
    }
  }
  delay(750);
}

void moveServo(uint8_t servo, uint16_t position, uint16_t time)
{
  Serial.print("#");
  Serial.print(servo);
  Serial.print("P");
  Serial.print(position);
  Serial.print("T");
  Serial.println(time);
}

Descarga el código

Todo el código de esta entrada está disponible para su descarga en Github.