• Leer el sensor de color TCS3200
• Detectar si se observa el color rojo (lo que se interpretaría como que el tomate está maduro)
• Activar un servomotor para recoger el tomate (abrir/cerrar un "brazo")
• Activar un segundo servomotor para accionar unas tijeras que cortan el tallo
• Activar un tercer servomotor para desplazar el tomate a un compartimiento de guardado
• Activar un motor paso a paso (con su driver) para mover el prototipo entre plantas

Nota: Los pines asignados y los valores umbral de detección del color se deben ajustar según tu hardware y pruebas de calibración. Este código es un ejemplo básico de la secuencia.

Cpp
#include <Arduino.h>
#include <Servo.h>

// ==============================
// Definición de pines para el TCS3200
// ==============================
const int TCS_S0   = 12;
const int TCS_S1   = 13;
const int TCS_S2   = 14;
const int TCS_S3   = 27;
const int TCS_OUT  = 26;  // Pin para salida de frecuencia

// ==============================
// Definición de pines para los servomotores
// ==============================
const int SERVO_GRIPPER_PIN  = 33; // Servomotor del brazo para recoger tomate
const int SERVO_SCISSOR_PIN  = 32; // Servomotor para accionar tijeras (corte de tallo)
const int SERVO_ARM_PIN      = 15; // Servomotor para mover el tomate a la zona de guardado

Servo servoGripper;
Servo servoScissor;
Servo servoArm;

// ==============================
// Definición de pines para el motor paso a paso
// (Driver tipo A4988/DRV8825)
// ==============================
const int STEPPER_STEP_PIN = 18;
const int STEPPER_DIR_PIN  = 19;
  
// Parámetros de movimiento del motor paso a paso
const int STEPS_TO_MOVE = 200;  // Número de pasos para trasladarse de una planta a otra
const int STEP_DELAY_MS = 2;    // Retardo entre pasos

// ==============================
// Parámetros para la detección de color (Tomate maduro = rojo)
// ==============================
// Estos valores deberán calibrarse. Supongamos que al configurar S2,S3 para rojo, 
// el TCS3200 emite una frecuencia mayor (o menor) según la intensidad del rojo.
const float RED_THRESHOLD_LOW  = 1000;  // Umbral inferior (Hz)
const float RED_THRESHOLD_HIGH = 1500;  // Umbral superior (Hz)

  
// Función para configurar el TCS3200
void setupTCS3200() {
  pinMode(TCS_S0, OUTPUT);
  pinMode(TCS_S1, OUTPUT);
  pinMode(TCS_S2, OUTPUT);
  pinMode(TCS_S3, OUTPUT);
  pinMode(TCS_OUT, INPUT);
  
  // Configuración de escala de frecuencia: Por ejemplo, 20% de salida
  digitalWrite(TCS_S0, HIGH);
  digitalWrite(TCS_S1, LOW);
  
  // Configurar el filtro para medir el rojo:
  // (S2=LOW, S3=LOW) selecciona los fotodiodos rojos
  digitalWrite(TCS_S2, LOW);
  digitalWrite(TCS_S3, LOW);
}

// Función para leer la frecuencia del TCS3200
float readColorFrequency() {
  // Usamos pulseIn para medir el ancho del pulso en microsegundos
  unsigned long pulseWidth = pulseIn(TCS_OUT, LOW, 1000000);  // Timeout de 1 segundo
  
  if(pulseWidth == 0){
    return 0.0;  // Indica error de lectura
  }
  
  // La frecuencia se puede estimar como 1 seg / período en segundos. 
  float frequency = 1000000.0 / pulseWidth; 
  return frequency;
}

// Función para controlar el motor paso a paso
void moveStepper(int steps, int direction) {
  digitalWrite(STEPPER_DIR_PIN, direction);
  for (int i = 0; i < steps; i++) {
    digitalWrite(STEPPER_STEP_PIN, HIGH);
    delay(STEP_DELAY_MS);
    digitalWrite(STEPPER_STEP_PIN, LOW);
    delay(STEP_DELAY_MS);
  }
}

void setup() {
  Serial.begin(115200);
  
  // Inicializa el TCS3200
  setupTCS3200();
  
  // Inicialización de servos
  servoGripper.attach(SERVO_GRIPPER_PIN);
  servoScissor.attach(SERVO_SCISSOR_PIN);
  servoArm.attach(SERVO_ARM_PIN);
  
  // Configuración de pines para el motor paso a paso
  pinMode(STEPPER_STEP_PIN, OUTPUT);
  pinMode(STEPPER_DIR_PIN, OUTPUT);
  
  // Posiciones iniciales de los servos
  // Suponiendo que 0° es "cerrado" y 90° es "abierto", se deben ajustar según el mecanismo:
  servoGripper.write(0);  // Brazo inicialmente cerrado
  servoScissor.write(0);  // Tijeras en posición inicial (sin corte)
  servoArm.write(0);      // Brazo de traslado en posición inicial
}

void loop() {
  // Lee la frecuencia en la configuración para detectar rojo
  float redFrequency = readColorFrequency();
  Serial.print("Frecuencia medida (Rojo): ");
  Serial.println(redFrequency);
  
  // Si la lectura es válida y se encuentra en el rango configurado para rojo
  if(redFrequency > RED_THRESHOLD_LOW && redFrequency < RED_THRESHOLD_HIGH) {
    Serial.println("Detección: Tomate maduro (Rojo). Iniciando secuencia...");
    
    // 1. Activar servomotor del brazo para recoger el tomate
    //    Ejemplo: abrir el brazo (ángulo abierto) para sujetar el tomate
    servoGripper.write(90);
    delay(1000);  // Esperamos 1 segundo para completar la acción
    
    // 2. Activar servomotor de las tijeras para cortar el tallo
    servoScissor.write(90);  // Cerrar tijeras para cortar (ajustar según mecanismo)
    delay(1000);
    servoScissor.write(0);   // Abrir tijeras luego del corte
    delay(500);
    
    // 3. Mover el brazo para trasladar el tomate a la zona de guardado
    servoArm.write(90);    // Mover a posición de traslado
    delay(1000);
    servoGripper.write(0); // Soltar el tomate en el compartimento
    delay(500);
    servoArm.write(0);     // Regresar brazo a posición inicial
    delay(500);
    
    // 4. Activar el motor paso a paso para trasladarse a la siguiente planta
    //    Se asume que "direction" = HIGH para avanzar
    moveStepper(STEPS_TO_MOVE, HIGH);
    delay(1000);
  }
  
  // Espera un momento antes de volver a leer
  delay(500);
}

1. Sensor TCS3200:
   • Se configuran los pines de control (S0, S1, S2, S3) para establecer la escala y el filtro rojo.
   • La función readColorFrequency() lee la frecuencia generada y se calcula su valor.
2. Servomotores:
   • Tres servos se manejan con la librería Servo para: abrir el brazo de agarre, accionar las tijeras y mover el brazo para depositar el tomate en la zona de guardado.
   • Las posiciones (ángulos) se establecen de manera ejemplar y deben calibrarse según el mecanismo.
3. Motor Paso a Paso:
   • Se controla mediante dos pines (STEP y DIR) en una función moveStepper() que mueve el motor un número definido de pasos.
4. Secuencia de Operación:
   • Si la frecuencia leída se encuentra en el rango definido (indicando tomate maduro en rojo), se activa la secuencia: recoger, cortar, transferir y mover el prototipo a otra planta.