How-To Archives - The Borikengineers (FTC Team #20380)

Programador de Servos Wi-Fi: De la Necesidad a la Solución de Campo

Jose Miranda (Mentor) — Sat, 21 Feb 2026 02:20:13 +0000

En el taller de Borikengineers, este proyecto nació de una necesidad absoluta. Durante el desarrollo y las pruebas en robótica competitiva, cambiar la configuración de un servo de modo continuo a modo posicional (o viceversa) suele ser un proceso tedioso. Necesitábamos una herramienta de campo que fuera rápida, confiable y que no dependiera de estar conectados a una computadora portátil en medio de los pits.

Así nació nuestro Programador de Servos Wi-Fi, impulsado por un ESP8266 (NodeMCU V3) y controlable completamente desde un teléfono móvil sin necesidad de internet.

Dando Honor a Quien Honor Merece: La Comunidad de Chief Delphi

Antes de hablar de la interfaz y la conectividad, es vital reconocer de dónde provino la “magia” de este proyecto. La ingeniería inversa y el trabajo pesado para descubrir las secuencias de bytes hexadecimales exactas necesarias para flashear la memoria EEPROM de estos servos no fue obra nuestra.

Ese mérito pertenece a la increíble comunidad de Chief Delphi. Encontramos un código base funcional en este hilo del foro: Reprogramming Dual Mode Servo Using Arduino. El usuario Asaf Meizner, alumni del equipo Makers Assemble 5951, creó el script original para enviar los comandos a través de Arduino. Nosotros tomamos esa excelente base y la llevamos al siguiente nivel para crear una herramienta de grado de campo.

Nuestra aportació: Una Interfaz Inalámbrica y Elegante

El script original requería enviar comandos a través del Monitor Serie de una computadora. Nosotros decidimos empaquetar esa lógica dentro de un servidor web autónomo alojado en un NodeMCU.

Las características de nuestra versión incluyen:

Punto de Acceso Independiente: El NodeMCU crea su propia red Wi-Fi (Borik-Servo-Tool). Te conectas desde tu teléfono, abres el navegador y la herramienta está lista.
Interfaz Móvil Nativa: Utilizando HTML, CSS y JavaScript alojados directamente en la memoria del microcontrolador, diseñamos una interfaz que se siente como una aplicación móvil profesional. Cuenta con botones táctiles con animaciones, notificaciones emergentes (Toasts) y bloqueos de seguridad para evitar dobles clics accidentales durante el flasheo.
Banco de Pruebas Integrado: No solo flasheamos el servo, sino que añadimos una sección de “Test Bench” para enviar señales PWM de 1000µs, 1500µs y 2000µs inmediatamente después de la programación para validar el movimiento.
Lógica a Prueba de Fallos: Implementamos un sistema de control de pines dinámico, alternando entre OUTPUT e INPUT_PULLUP para la comunicación UART (RX/TX), junto con comandos de “Signal Wash” para asegurar que el motor no se mueva erráticamente al terminar de programarse.

El Hardware

El circuito es engañosamente simple, utilizando una configuración UART Half-Duplex:

Un NodeMCU V3 (ESP8266).
El pin D1 (RX) escucha las respuestas del servo.
El pin D2 (TX) envía los comandos de programación y la señal PWM.
Una resistencia de 470Ω conectada entre D2 y el cable de señal del servo para proteger el microcontrolador de colisiones de datos.

Componentes Eléctricos

Microcontroller: ESP8266 NodeMCU V3.
Resistencia (Importante): 470Ω a 1kΩ (1/4 Watt).
- Localización: Entre el pin D2 y el cable de señal del servo.
- Propósito: Sirve para proteger el NodeMCU cuando el servo responde a la señal que se le envia. Ya que la señal del servo es de 5V, mientras que el NodeMCU espera un voltaje de 3.3V. La resistencia ayuda a mantener la corriente en un nivel tolerable.

Fuente de poder
- Para servos pequeños puedes usar el pin VIN si estas conectado a USB.
- Para servos grandes de alto torque necesitas una fuente de poder externa o un paquete de baterias de 5V a 6V y asegurarte de conectar el negativo de la bateria al GND del NodeMCU.

Instrucciones de Alambrado

Union de señales
- Toma el cable blanco o naranja del servo.
- Conectalo directamente al pin D1 del NodeMCU.
- Conecta el mismo cable a una resistencia de 470Ω.
- Conecta el otro lado del resitor al pin D2 del NodeMCU.
Poder
- Conecta el cable rojo del servo al positivo de una fuente externa de poder de 5V o a pin VIN del NodeMCU.
- Conecta el cable negro del servo al pin GND del NodeMCU
- Si usas una fuente de poder externa, conecta el negativo al GND del NodeMCU.

Aqui te dejo un diagrama de la conexión:

     NODE MCU V3 (ESP8266)                          SERVO MOTOR
   +-----------------------+                    +-----------------+
   |                       |                    |                 |
   |                   GND |--------------------| Negro / Marrón  |
   |                       |                    |                 |
   |              VIN (5V) |--------------------| Rojo (VCC)      |
   |                       |                    |                 |
   |             D1 (GPIO5)|--------------+     |                 |
   |             (RX Input)|              |     |                 |
   |                       |              +-----| Blanco / Naranja|
   |             D2 (GPIO4)|----[470Ω]----^     | (Señal)         |
   |             (TX/PWM)  |   Resistencia      |                 |
   +-----------------------+                    +-----------------+

El Código Completo: Construye tu Propio Programador

Para aquellos que quieran replicar esta herramienta en sus propios talleres, aquí compartimos el código fuente completo para el NodeMCU V3. Hemos empaquetado toda la interfaz web, el manejo de Wi-Fi y la lógica de programación en un solo archivo .ino para facilitar su implementación.

Necesitas instalar el compilador de Arduino. Una vez instalado, ve a File>Preferences, y en Additional Board Manager URLs pon esta direccion:

https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json

Luego abres Tool>Board>Boards Manager, buscas “ESP8266” e instalas el que se ve abajo. Eso te permitira compilar y subir el codigo al NodeMCU.

Este es el código. Tambien puedes conseguirlo en nuestro repositorio en Github.

/* ============================================================================
 * Project: Borikengineers Servo Programmer & Test Bench
 * Author:  Borikengineers FTC Team 20380
 * Origin:  Aguadilla, Puerto Rico
 *
 * Description: 
 * This code configures an ESP8266 to host a local web server network 
 * ("Borik-Servo-Tool") to program and test servos via a mobile-friendly UI. 
 *
 * License:
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * ============================================================================ */

#include       // Core Wi-Fi library for ESP8266
#include  // Library to host the local web server
#include    // Allows serial communication on custom pins
#include             // Standard library to generate PWM signals for servos

// Define hardware pins used for communicating with the servo
#define RX_PIN D1
#define TX_PIN D2 

// Initialize objects
SoftwareSerial mySerial(RX_PIN, TX_PIN); // Serial connection for programming the servo
Servo myServo;                           // PWM connection for testing the servo
ESP8266WebServer server(80);             // Web server running on standard HTTP port 80

// State flag to prevent concurrent requests from crashing the serial sequence
bool isBusy = false;

// Helper function to clear the incoming serial buffer
// This ensures old responses don't interfere with new commands
void flushMySerial() {
  while (mySerial.available()) { mySerial.read(); }
}

// Configures the servo to operate in Positional Mode (Standard 0-180 degree operation)
void sendServoModeSequence() {
  if(isBusy) return; // Block execution if another operation is running
  isBusy = true;
  
  // Stop sending PWM signals before attempting serial communication on the same line
  myServo.detach();
  delay(500);

  // Command 1: Initialization / Wake-up sequence
  pinMode(TX_PIN, OUTPUT);
  byte s1[] = {0xFF,0xFF,0xFE,0x02,0x01,0xFE};
  mySerial.write(s1, sizeof(s1));
  pinMode(TX_PIN, INPUT_PULLUP); // Switch to input to allow the servo to pull the line (half-duplex simulation)
  delay(10); flushMySerial();

  // Command 2: Main configuration payload for Positional Mode
  pinMode(TX_PIN, OUTPUT);
  byte s4s[] = {0xFF,0xFF,0x01,0x2F,0x03,0x06,0x02,0x1E,0x00,0x05,0x00,0x0F,0x00,0x2D,0x00,0x00,0x00,0x00,0x0F,0x03,0xFC,0x00,0x00,0x00,0x00,0x41,0x03,0xC5,0x00,0x00,0x01,0xFF,0x01,0x00,0x02,0x09,0xC4,0x01,0xF4,0x03,0xE8,0x00,0x01,0x00,0x00,0x00,0x00,0x03,0xE8,0x00,0xB2};
  mySerial.write(s4s, sizeof(s4s));
  pinMode(TX_PIN, INPUT_PULLUP);
  delay(10); flushMySerial();

  // Command 3: Finalize / Save to EEPROM
  pinMode(TX_PIN, OUTPUT);
  byte s5[] = {0xFF,0xFF,0x01,0x04,0x03,0x34,0x01,0xC2};
  mySerial.write(s5, sizeof(s5));
  pinMode(TX_PIN, INPUT_PULLUP);
  delay(10); flushMySerial();
  
  isBusy = false; // Release the lock
}

// Configures the servo to operate in Continuous Rotation Mode (360 degree wheel mode)
void sendContinuousModeSequence() {
  if(isBusy) return;
  isBusy = true;
  
  myServo.detach();
  delay(500);

  // Command 1: Initialization / Wake-up sequence
  pinMode(TX_PIN, OUTPUT);
  byte s1[] = {0xFF,0xFF,0xFE,0x02,0x01,0xFE};
  mySerial.write(s1, sizeof(s1));
  pinMode(TX_PIN, INPUT_PULLUP);
  delay(10); flushMySerial();

  // Command 2: Main configuration payload for Continuous Mode
  pinMode(TX_PIN, OUTPUT);
  byte s4c[] = {0xFF,0xFF,0x01,0x2F,0x03,0x06,0x32,0x14,0x00,0x05,0x00,0x0A,0x00,0x0A,0x00,0x1E,0x00,0x00,0x00,0x03,0xFF,0x01,0x00,0x00,0x00,0x41,0x03,0xC5,0x01,0xF4,0x01,0xFF,0x00,0x00,0x02,0x06,0x0E,0x05,0xAA,0x03,0xE8,0x00,0x14,0x00,0x00,0x00,0x00,0x03,0xE8,0x00,0x99};
  mySerial.write(s4c, sizeof(s4c));
  pinMode(TX_PIN, INPUT_PULLUP);
  delay(10); flushMySerial();

  // Command 3: Finalize / Save to EEPROM
  pinMode(TX_PIN, OUTPUT);
  byte s5[] = {0xFF,0xFF,0x01,0x04,0x03,0x34,0x01,0xC2};
  mySerial.write(s5, sizeof(s5));
  pinMode(TX_PIN, INPUT_PULLUP);
  delay(10); flushMySerial();
  
  isBusy = false;
}

// Generates the HTML, CSS, and JS for the web interface
String getHTML() {
  // Capture URL arguments to display toast notifications (e.g., /?msg=Success)
  String msg = server.arg("msg");
  msg.replace("+", " ");
  String displayMode = (msg == "") ? "none" : "block";

  // Build the HTML page structure
  String html = "";
  html += "";
  html += "Borikengineers Tool";
  
  // Inject CSS styling
  html += "";

  // Inject JavaScript for UI interactions
  html += "";

  // Build the HTML body elements and route links
  html += "";
  html += "Borikengineers
Servo Programmer";
  html += "";
  html += "" + msg + ""; // Display success messages here
  html += "";
  html += "Program Mode
";
  html += "FLASH CONTINUOUS";
  html += "FLASH POSITIONAL";
  html += "";
  html += "";
  html += "Test Bench";
  html += "";
  html += "FWD / 180°"; // 2000 microseconds = max forward
  html += "REV / 0°";    // 1000 microseconds = max reverse
  html += "";
  html += "STOP / 90°";  // 1500 microseconds = center/stop
  html += "";
  html += "Borik Engineers | Field Tool v3.0";
  html += "";
  return html;
}

void setup() {
  // Serial setup for debugging
  Serial.begin(115200);
  
  // Software Serial setup for servo communication (Servos often use specific baud rates)
  mySerial.begin(76800);
  
  // Default TX pin to input with pullup to idle high
  pinMode(TX_PIN, INPUT_PULLUP);

  // Set up the ESP8266 as an Access Point
  WiFi.softAP("Borik-Servo-Tool", "12345678");

  // Route: Main Page
  server.on("/", [](){ server.send(200, "text/html", getHTML()); });
  
  // Route: Handle programming requests
  server.on("/set", [](){
    if(isBusy) return;
    String mode = server.arg("m");
    String responseMsg = "";
    
    // Check which mode the user selected
    if(mode == "1") {
      sendContinuousModeSequence();
      responseMsg = "Continuous+Mode+Activated";
    } else {
      sendServoModeSequence();
      responseMsg = "Positional+Mode+Activated";
    }
    
    // Redirect back to the main page with a success message
    server.sendHeader("Location", "/?msg=" + responseMsg);
    server.send(303);
  });

  // Route: Handle PWM test movements
  server.on("/move", [](){
    if(isBusy) return;
    
    // Read the requested pulse width (in microseconds)
    int pulse = server.arg("v").toInt();
    
    // Re-attach the servo to the TX pin for standard PWM generation
    myServo.attach(TX_PIN);
    myServo.writeMicroseconds(pulse);
    
    // Redirect back to the main page
    server.sendHeader("Location", "/");
    server.send(303);
  });

  // Start the web server listener
  server.begin();
}

void loop() { 
  // Continuously listen for incoming HTTP requests
  server.handleClient(); 
}

Como usar la herramienta

Una vez compilas el codigo y lo subes al NodeMCU el programa se inicia y se crea el punto de acceso WiFi llamado Borik-Servo-Tool. El password es: 12345678. El nombre y password se puede cambiar en el código cambiando esta linea:

WiFi.softAP("Borik-Servo-Tool", "12345678");

Una vez conectado al punto de acceso, abres un navegador de internet y entras la siguiente direccion: 192.168.4.1

Al entrar veras esta pantalla

Servo Programmer

El programa es bien simple. La parte de arriba (Program Mode) te permite programar el servo en modo de rotación continua o modo posicional. La parte de abajo (Test Bench) te permite mover el servo para probarlo.

Conclusión

Este es un ejemplo perfecto de cómo el código abierto y la colaboración en línea impulsan la ingeniería hacia adelante. Tomamos una solución brillante de la comunidad de Chief Delphi y le aplicamos nuestra experiencia en interfaces web y sistemas integrados para crear una herramienta indispensable para nuestro equipo.

Esperamos que esta herramienta le sirva a otros equipos para ser más eficientes durante las competencias. Un enorme agradecimiento nuevamente a la comunidad de Chief Delphi por hacer el trabajo pesado de ingeniería inversa. Si integras este código en tu taller, ¡déjanos un comentario o etiquétanos en redes sociales!

The post Programador de Servos Wi-Fi: De la Necesidad a la Solución de Campo appeared first on The Borikengineers (FTC Team #20380).

Coiled servo motor cable

Jose Miranda (Mentor) — Tue, 03 Jan 2023 22:31:18 +0000

This is the first time we use a slider in our robot, and we quickly noticed an issue with the design. We are using a servo motor to move a gripper mounted on the slider. Since it has to reach a height of almost 3 feet, we used several servo extensions. There are several problems with this. With the continuous up and down movement of the gripper, the extensions tend to disconnect from each other. Also, when it extends up and then down the cable can get tangled on the robot’s parts, or even worse, it can be cut!

Our mentor mentioned the coiled cables that were used on telephones in the past. That would be a good solution, but after checking the FTC rules, the servo cable must be either the same wire gauge that the servo comes with, or gauge 22. We could not source a coiled telephone cable with documented wire gauge. But we found a method online for creating coiled cables out of regular cable that involves heating the cable while it is wrapped around a wooden dowel. However, since our cable is going to be repeatedly extended, we modified the process a little bit. This post serves as documentation of the process, and we are sharing it so that it is useful to other First Tech Challenge (FTC) teams. Here is the process we followed:

Materials:

Gauge 22 stranded cable (FTC required gauge for servos). 8 Feet will result in about 2 ft of coiled cable, depending on the rod diameter. We used 4 copper wire shielded and grounded cable. We sourced it locally, but it would be better to use a 3 wire cable instead. This is probably a good choice from Amazon.com: Striveday 22 AWG 4 conductor wire Power Cable Audio Cable Signal Line (Red & Black & yellow & white) 33ft UL certification : Electronics
Heat shrinking tubes a little bit bigger than the cable diameter.
Heat shrinking tube a little bit bigger than the individual wires.
Any kind of rod or wooden dowel, as long as the end length of the coiled cable.
Hair dryer, or heat gun (better).
1 Servo extension cable (short).
Soldering iron
Solder
Multimeter

Process:

Insert the cable in two 4 feet long heat shrinking tubes.
- We used two 4 ft tubes, so we had to add an overlap at the middle by heating one tube a little bit so that it shrinks and can be inserted into the other.
- Inserting the tubes is not an easy task. The longer the heat shrinking tube, the better the results. Also, using a heat shrinking tube that is just bigger than the cable results in a tighter coil.
- Leave the ends of the cable free (no heat shrink tube).
Wrap the cable around the rod. We used an aluminum rod about 1/2 in.
Tape the ends so that it does not uncoil.
- We noticed that even though the initial wrapping was very tight, as the tubes start to shrink it loses some tightness. It may be better to hold only one end and try to keep the coil tight on the other end while heat is applied.
Apply heat to the cable evenly to shrink the tubes. Take your time in this step and make sure the whole length of the cable shrinks. Rotate the rod to ensure both sides are heated evenly.
Remove the tape and remove the cable from the rod.
Apply more heat to ensure all the tube has shrunk.
Strip the ends of the cable.
Check all the wires for continuity and shorts
- For continuity, check every wire color against the same color on the other end. It should beep on each wire.
- For shorts, check every wire color against the other two colors on the other end. It should not beep.
Take the servo extension and cut it in the middle.
Solder each halve of the servo extension cable to the ends of your coiled cable. The colors you use do not matter, as long as you are consistent on both sides. We soldered red to red, black to black, and white to yellow. The green wire, ground, and shield were not needed so we just cut them.
- Before soldering the wires, insert a piece of the large shrinking tube and slide it out of the way. This will be used to cover all the wires after soldered. Also, insert about 1 inch of the smaller shrinking tube on each wire.
Slide the small diameter tubes to cover the solder and heat them. This will ensure there are not shorts between the cables.
It is a good idea to check the cable for continuity and shorts again, but this time at the plugs.
Slide the large diameter tubes to cover the soldered wires while keeping a little bit of overlap with the already shrunk tube, then apply heat.

It took us about 1 hour to complete this process with the help of our mentors. The most difficult part is inserting the cable in the heat shrinking tube since each piece is 4 feet long and the friction makes it hard to insert. The end result is really good! We have been using that cable for some time now with zero issues. Below are some pictures and videos of key steps of the process. Please do not look at the mess in the background!

Coiled and taped cable

Applying heat

Heating up the coil while rotating the rod

Extending the cable and applying more heat

Soldering the individual wires

Coiled cable in use

The post Coiled servo motor cable appeared first on The Borikengineers (FTC Team #20380).