Comandar el brazo a distancia con seis potenciómetros

// Brazo robotico — Nivel Intermedio (Arduino UNO).
//
// MANDO A DISTANCIA: seis potenciometros comandan los seis servomotores, uno
// por articulacion. Cada potenciometro actua como perilla de posicion: al
// girarlo, el servo correspondiente sigue su angulo. Es el "control remoto"
// que pide la situacion-problema (manipular sustancias peligrosas sin contacto).
//
// Plataforma: Arduino UNO con IO Shield de DFRobot. Las entradas analogicas
// A0..A5 leen los potenciometros; los pines 2..7 mandan los servos.
//
// ATENCION — ALIMENTACION: FUENTE EXTERNA 5V 2A obligatoria (6 servos no van
// por USB), GND comun. ATENCION — MECANICA: 6 grados de libertad; al mover los
// potenciometros el brazo puede golpear. Despejar la zona.
//
// Adaptacion de escala (regla de tres del Paso 3): el ADC del UNO entrega
//   0..1023 (10 bits) y el servo acepta 0..180 grados. Angulo = lectura*180/1023.
//
// Nivel intermedio: se permite delay() para dar una cadencia de refresco suave.
//
// Basado en: Fragmentos de codigo del Nivel Intermedio, Pasos 3 a 5 — Brazo
// Robotico, Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README):
//  (1) mBlock3 -> C++ limpio (sin angle_rad/deg, sin _delay/_loop, sin
//      servo_2..servo_7): arreglos indexados y una funcion de mapeo reutilizable.
//  (2) El original arrancaba tres potenciometros y despues sumaba tres mas; aca
//      se entregan los SEIS desde el inicio (es el estado final del Paso 5).

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Servomotores (contrato UNO: pines digitales 2..7) ---
const int CANT_SERVOS = 6;
const int PINES_SERVO[CANT_SERVOS] = {2, 3, 4, 5, 6, 7};

// --- Potenciometros (contrato UNO: entradas analogicas A0..A5) ---
// PIN_POT[i] controla PINES_SERVO[i] (misma articulacion).
const int PINES_POT[CANT_SERVOS] = {A0, A1, A2, A3, A4, A5};

// Escala del ADC del UNO: 10 bits -> valor maximo 1023.
const long ADC_MAX = 1023;
const int ANGULO_MAX = 180;

// Cadencia de refresco (ms). Suaviza la lectura sin bloquear percepcion.
const unsigned long REFRESCO_MS = 15;

Servo servos[CANT_SERVOS];

// Convierte una lectura del ADC (0..ADC_MAX) al angulo del servo (0..180)
// con la regla de tres del original. Se usa long para no desbordar en el
// producto lectura*180 antes de dividir.
int lecturaAAngulo(int lectura) {
  return (int)(((long)lectura * ANGULO_MAX) / ADC_MAX);
}

void setup() {
  for (int i = 0; i < CANT_SERVOS; i++) {
    pinMode(PINES_POT[i], INPUT);
    servos[i].attach(PINES_SERVO[i]);
    // Arranque seguro: centrar cada servo antes de tomar el mando del pote.
    servos[i].write(90);
  }
}

void loop() {
  // Leer los seis potenciometros y reflejar cada uno en su servo.
  for (int i = 0; i < CANT_SERVOS; i++) {
    int lectura = analogRead(PINES_POT[i]);
    servos[i].write(lecturaAAngulo(lectura));
  }
  delay(REFRESCO_MS);
}

// Brazo robotico — Nivel Intermedio (ESP32 DevKit v1).
//
// MANDO A DISTANCIA: seis potenciometros comandan los seis servomotores, uno
// por articulacion (el "control remoto" de la situacion-problema).
//
// Plataforma: ESP32 (DevKit v1), servos con ESP32Servo, SIN shield (cableado
// directo). El mapa de pines del ESP32 es AJUSTADO: 6 servos + 6 entradas
// analogicas es lo maximo que entra sin colisiones (ver README, tabla ESP32).
//
// Mapa resuelto SIN COLISIONES:
//   Servos  -> GPIO 13, 14, 25, 26, 27, 32
//   Pots    -> GPIO 36, 39, 34, 35 (ADC1 solo-entrada) + GPIO 33 (ADC1) + GPIO 4
//   * GPIO 32 es SERVO, no pote: no puede ser las dos cosas. Por eso el pote que
//     el contrato ubicaba en 32 se reubica a GPIO 4.
//   * GPIO 4 es ADC2. El ADC2 solo entra en conflicto cuando el WiFi esta
//     activo; este proyecto NO tiene IoT/WiFi, asi que GPIO 4 lee sin problemas.
//
// ATENCION — ALIMENTACION: FUENTE EXTERNA 5V 2A obligatoria (6 servos), GND
// comun. Los potenciometros se alimentan a 3,3 V (no a 5 V): el ADC del ESP32
// mide 0..3,3 V; con 5 V se satura la lectura y se dana el pin.
// ATENCION — MECANICA: 6 grados de libertad; al mover los potes el brazo puede
// golpear. Despejar la zona.
//
// Adaptacion de escala: el ADC del ESP32 entrega 0..4095 (12 bits, contra los
// 10 bits / 0..1023 del UNO). Angulo = lectura*180/4095.
//
// Nivel intermedio: se permite delay() para una cadencia de refresco suave.
//
// Basado en: Fragmentos de codigo del Nivel Intermedio, Pasos 3 a 5 — Brazo
// Robotico, Saberes Digitales (INET/EDUCAR 2019).
// Desvios (ver README): mBlock3 -> C++ limpio; GPIO seguros; ADC de 12 bits
// (÷4095 en vez de ÷1023); reubicacion del pote 6 a GPIO 4 para evitar colision
// con el servo 6 (GPIO 32); los seis potes desde el inicio (estado final Paso 5).

#if defined(ESP32)
  #include <ESP32Servo.h>
#else
  #include <Servo.h>
#endif

// --- Servomotores (contrato ESP32) ---
const int CANT_SERVOS = 6;
const int PINES_SERVO[CANT_SERVOS] = {13, 14, 25, 26, 27, 32};

// --- Potenciometros (mapa ESP32 resuelto sin colisiones) ---
// PINES_POT[i] controla PINES_SERVO[i].
//   36,39,34,35 = ADC1 solo-entrada | 33 = ADC1 | 4 = ADC2 (libre sin WiFi)
const int PINES_POT[CANT_SERVOS] = {36, 39, 34, 35, 33, 4};

// Escala del ADC del ESP32: 12 bits -> valor maximo 4095.
const long ADC_MAX = 4095;
const int ANGULO_MAX = 180;

const unsigned long REFRESCO_MS = 15;

Servo servos[CANT_SERVOS];

// Regla de tres: lectura del ADC (0..ADC_MAX) -> angulo del servo (0..180).
// long evita el desborde del producto lectura*180 antes de dividir.
int lecturaAAngulo(int lectura) {
  return (int)(((long)lectura * ANGULO_MAX) / ADC_MAX);
}

void setup() {
  for (int i = 0; i < CANT_SERVOS; i++) {
    pinMode(PINES_POT[i], INPUT);
    servos[i].attach(PINES_SERVO[i]);
    servos[i].write(90);  // arranque seguro: centrar antes de dar el mando
  }
}

void loop() {
  for (int i = 0; i < CANT_SERVOS; i++) {
    int lectura = analogRead(PINES_POT[i]);
    servos[i].write(lecturaAAngulo(lectura));
  }
  delay(REFRESCO_MS);
}