2 ultrasónicos 2 servos en un arduino

Que tal
estoy en un proyecto escolar y tengo el siguiente código pero al detectar un sensor se activa el servo correcto y enseguida el segundo, en ocasiones lo hace correctamente y otras se activan uno tras otro solo detectando uno de ellos cual sea.

requiero que solo se active el servo requerido según sea el caso y el otro permanezca desactivado o se active cada servo con su propio sensor. (como que se confunden )

de antemano agradezco su ayuda
se muy poco aun de esto.
gracias por sus aportaciones.
aquí el código que tengo hasta ahora.

#include <Ultrasonic.h> //libreria para ultrasonico

#include <Servo.h> //libreria servo

int trigPin1=11; //pin trig del primer sensor
int echoPin1=10; //trig echo primer sensor

int trigPin2=6; //pin trig del segundo sensor
int echoPin2=5; //trig echo segundo sensor

Servo puerta_croquetas; //nombro servos
Servo puerta_agua;

void setup()
{
Serial.begin (9600);  //inicia monitor serial
pinMode(trigPin1, OUTPUT); //declara entradas y salidas de sensores
pinMode(echoPin1, INPUT);
pinMode(trigPin2, OUTPUT);
pinMode(echoPin2, INPUT); 
puerta_croquetas.attach(4);
puerta_agua.attach(7);
   
   
}

void loop()
//PUERTA CROQUETAS codigo para el primer servo
{
 long duration1, distance1;                                // ajusta primer sensor
 digitalWrite(trigPin1, LOW);  // Added this line
 delayMicroseconds(2); // Added this line
 digitalWrite(trigPin1, HIGH);
 delayMicroseconds(10); // Added this line
 digitalWrite(trigPin1, LOW);
 duration1 = pulseIn(echoPin1, HIGH);
 distance1 = (duration1/2) / 29.1;   
 
 if (distance1 >= 35 || distance1 <= 1){  //calcula distancia de detección primer sensor
  
   puerta_croquetas.write(180);  //envia servo a 180 si se cumple el paramentro de deteccion
   Serial.println("Out of range"); //imprime si esta fuera de rango
 }
 else {
   puerta_croquetas.write(90);  //envia servo a 90 si no detecta el sensor
   Serial.print ( "Sensor1  ");  //imprime distancia del sensor en cm
   Serial.print ( distance1);
   Serial.println("cm");
  delay (2000);                           //espera dos segundos entre cada evento de deteccion
 
 }
//PUERTA AGUA  //codigo para el segundo servo

    // Esperar 1 segundo entre mediciones
 delay(1000);            // espera 1 seguno antes de iniciar
long duration2, distance2;  //ajusta segundo sensor
 digitalWrite(trigPin2, LOW);  //desactiva pin2
 delayMicroseconds(2); // espera dos micrsegundos
 digitalWrite(trigPin2, HIGH); //activa el pin 2
 delayMicroseconds(10); // espera 10 microsegundos
 digitalWrite(trigPin2, LOW); //desactiva pin2
 duration2 = pulseIn(echoPin2, HIGH); //calcula la duración de la señal
 distance2= (duration2/2) / 29.1; //calcula la distanci

  if (distance2 >= 35 || distance2 <= 1){ conciona la distancia de deteccion entre 1 y 35 cm
   puerta_agua.write(180); //envia servo a 180 grados
   Serial.println("Out of range");  //imprime si esta fuera de rango
 }
 else {
    puerta_agua.write(90); //envia servo a 90 grados
    delay(2000);               //espera 2 segundos
   Serial.print("Sensor2  ");  /imprime sensor 2
   Serial.print(distance2);  //imprime la distancia del sensor 2
   Serial.println("cm");     //imprime cm
 }

Moderador: Código editado con etiquetas

Tienes dos servos y supongo que dos sensores ultrasónicos y un GRAN ABUSO de los DELAYS.

Dile de mi parte a tu profesor que no les enseñe mas a programar con DELAY y que les enseñe a usar millis().
POR FAVOR!!

Si tienes sensores y accciones que cumplir no puedes detener el flujo del programa por 1 o 2 o N segundos cuando te place porque esas detenciones FRENAN todo el programa no importa que ocurre.

Entonces... sensores sensan todo el tiempo
Y las acciones se deben dar cuando se cumplan las condiciones.

Y si quieres pausas para mostrar datos tmb puede hacerse pero sin DELAYs.

Veré como darle velta a tu código sin llevarte por un terreno que luzca como que te lo han hecho.

Mas alla de todo esto de los delays tu código tiene un problema y es este

Las dos condiciones FALSE que se dan cuando la distancia no esta entre 35 y 1 hace que se muestren las distancias y se accionen los delays de 2 seg cada vez mas 1 seg de pausa.

Eso por lo menos no es correcto porque mueve tu servo a posicion 90 grados en ambos casos.
Especulo que por ahi esta tu problema.
Estaba reescribiendo tu código cuando advertí que todo pasa por esas dos condiciones else que hacen que se cumplan siempre que no se den las otras condiciones claro esta.

gracias por tus comentarios

tratare de ver soluciones a eso que me comentas, y si puedes sugerir soluciones te lo agradeceré bastante.

por lo de las reglas del foro soy nuevo y la verdad no las leí.
por lo tanto una disculpa a quien corresponda por este post.

por cierto no es necesario que muestre los datos, lo que me importa es que funcionen.

Te envié privado para que edites.
Yo soy el moderador.

listo ya edite espero este bien asi

Activar el servo que significa, llevarlo a 180°?

asi es cuando detecta la distancia sugerida en el sensor va a 180 y cuando no va a 90

Prueba con esto solamente

#include <Ultrasonic.h> //libreria para ultrasonico
#include <Servo.h> //libreria servo

int trigPin1 = 11; //pin trig del primer sensor
int echoPin1 = 10; //trig echo primer sensor
int trigPin2 = 6; //pin trig del segundo sensor
int echoPin2 = 5; //trig echo segundo sensor
Servo puerta_croquetas; //nombro servos
Servo puerta_agua;

void setup() {
  Serial.begin (9600);  //inicia monitor serial
  pinMode(trigPin1, OUTPUT); //declara entradas y salidas de sensores
  pinMode(echoPin1, INPUT);
  pinMode(trigPin2, OUTPUT);
  pinMode(echoPin2, INPUT); 
  puerta_croquetas.attach(4);
  puerta_agua.attach(7);
}

void loop()  {
  //PUERTA CROQUETAS codigo para el primer servo

  long duration1, distance2;                                // ajusta primer sensor

  distance1 = ultrasonico(trigger1, echoPin1);

  if (distance1 >= 35 ){   // calcula distancia de detección primer sensor
      puerta_croquetas.write(180);          // envia servo a 180 si se cumple el paramentro de deteccion
      Serial.println("Out of range");       // imprime si esta fuera de rango
  }
  else {
      puerta_croquetas.write(90);           // envia servo a 90 si no detecta el sensor
      Serial.print ( "Sensor1  ");          // imprime distancia del sensor en cm
      Serial.print ( distance1);
      Serial.println("cm");
      delay (2000);                         // espera dos segundos entre cada evento de deteccion
  }
   
  //PUERTA AGUA  //codigo para el segundo servo
  // esperar 1 seg entre lecturas
  delay(1000);
  distance2 = ultrasonico(trigger2, echoPin2);
  if (distance2 >= 35){ conciona la distancia de deteccion entre 1 y 35 cm
      puerta_agua.write(180); //envia servo a 180 grados
      Serial.println("Out of range");  //imprime si esta fuera de rango
  }
  else {
      puerta_agua.write(90); //envia servo a 90 grados
      Serial.print("Sensor2  ");  /imprime sensor 2
      Serial.print(distance2);  //imprime la distancia del sensor 2
      Serial.println("cm");     //imprime cm
      delay(2000);               //espera 2 segundos
  }
}

long ultrasonico(int trigger, int echo) {
    long duration, distance;  //ajusta segundo sensor
    
    digitalWrite(trigger, LOW);  //desactiva pin2
    delayMicroseconds(2); // espera dos micrsegundos
    digitalWrite(trigger, HIGH); //activa el pin 2
    delayMicroseconds(10); // espera 10 microsegundos
    digitalWrite(trigger, LOW); //desactiva pin2
    duration = pulseIn(echo, HIGH); //calcula la duración de la señal
    distance= (duration2/2) / 29.1; //calcula la distanci
    
    return distancia;
 }

gracias por tu ayuda, lo hice como dijiste, pero siguen locas las puertas (servos).
los sensores no logran hacer su trabajo completamente por separado.
solo en ocasiones.

Agradezco infinitamente tu ayuda, disposición y ganas de contribuir con tus conocimientos a otras personas, ademas de tu gran calidad como persona con una gran capacidad no solo en lo técnico si no en lo humano.

En verdad estoy sumamente agradecido con tu colaboración a mi proyecto, quedo excelente.

como tu supusiste el problema era el botón.

Reemplace el normalmente cerrado por uno normalmente abierto y funciono de maravilla.
en verdad no se por que motivo, pero así fue.

Todo en lo que me ayudaste quedo excelente.

Ahora solo tengo que solucionar que la bomba de agua interfiere con los sensores cuando se activa esta, a pesar de que solo la tengo conectada a corriente y tierra del arduino y se activa por un flotador electrónico que no tiene programación en el arduino, pero que al parecer causa dicha interferencia.

Mil gracias de nuevo y estoy a tus ordenes, tienes un amigo en México para lo que se te ofrezca.
saludos.

Este es el código resultante que funciona correctamente.
ahora el problema que tengo es que al activar bomba de agua con el flotador electrónico genera problemas no se si con los servos o con los ultrasionicos que se vuelven locos y se abren y cierran las puertas de manera muy errante.
El flotador con la bomba están independientes del código, es decir solo lo tengo funcionando como un simple push button que activa o desactiva la mini bomba de agua.

aqui el codigo.

#include <Ultrasonic.h> //libreria para ultrasonico
#include <Servo.h> //libreria servo
#include <Bounce2.h> //librería anti rebote

const byte trigPin1 = 11; //pin trig del primer sensor
const byte echoPin1 = 10; //trig echo primer sensor
const byte trigPin2 = 6; //pin trig del segundo sensor
const byte echoPin2 = 5; //trig echo segundo sensor
const byte BOTON = 3; // define BOTON en el pin 3
const byte LED1 = A5; // define LED 1 en A5
const byte LED2 = 2; // define LED 2 en pin2
Bounce debouncer2 = Bounce(); // Crea la instancia del rebote

Servo puerta_croquetas; //nombro servos
Servo puerta_agua;
Servo sinfin;
bool val, valAnt = true; //define valor anterior como verdadero
bool flag1 = true, flag2 = true; //define variables flag1 y flag2 como verdaderas

void setup() {
Serial.begin (9600); //inicia monitor serial
pinMode(trigPin1, OUTPUT); //declara entradas y salidas de sensores
pinMode(echoPin1, INPUT);
pinMode(trigPin2, OUTPUT);
pinMode(echoPin2, INPUT);
puerta_croquetas.attach(4); // Indica servo croquetas en pin 4
puerta_agua.attach(8); // Indica servo agua en pin 8

pinMode(BOTON,INPUT); // Define BOTON como entrada
debouncer2.attach(BOTON); // Lee el rebote del boton
debouncer2.interval(50); // interval in ms
sinfin.attach(9); //Servo sinfin en pin 9
}

void loop() {

debouncer2.update(); //Actualiza el rebote

//PUERTA CROQUETAS codigo para el primer servo
long duration1, distance1; // ajusta primer sensor

distance1 = ultrasonico(trigPin1, echoPin1);

if (distance1 >= 35 ){ // calcula distancia de detección primer sensor
puerta_croquetas.write(180); // envia servo a 180 si se cumple el paramentro de deteccion
if (flag1) {
Serial.println(“S1 Out of range”); // imprime si esta fuera de rango
flag1 = false;
}
}
else {
puerta_croquetas.write(90); // envia servo a 90 si no detecta el sensor
Serial.print ( "Sensor1 "); // imprime distancia del sensor en cm
Serial.print ( distance1);
Serial.println(“cm”);
flag1 = true;
}

//PUERTA AGUA //codigo para el segundo servo
long duration2, distance2;
distance2 = ultrasonico(trigPin2, echoPin2);
if (distance2 >= 35){ // conciona la distancia de deteccion entre 1 y 35 cm
puerta_agua.write(180); //envia servo a 180 grados
if (flag2) {
Serial.println(“S2 Out of range”); //imprime si esta fuera de rango
flag2 = false;
}
}
else {
puerta_agua.write(90); //envia servo a 90 grados
Serial.print("Sensor2 "); //imprime sensor 2
Serial.print(distance2); //imprime la distancia del sensor 2
Serial.println(“cm”); //imprime cm
flag2 = true;
}

// SINFIN CON LEDS
// val = digitalRead(BOTON); //Lee el valor del BOTON

val = debouncer2.read(); //Lee el valor del rebote
if (val != valAnt) // Compara los valores actuales y anteriores del BOTON
Serial.println(val?“Boton ON”:“Boton OFF”); //Imprime el estado actual del BOTON

if (val && !valAnt) { // veo transiciion de 0 a 1 o de NC a NO
Serial.println(“Sinfin girando.”); // Muestra dicha transición el el monitor serial
digitalWrite(LED1,HIGH); //Enciende LED1

digitalWrite(LED2,LOW); //Apaga LED2
sinfin.write(90); // Envia Servo sinfin a 90
}
if (!val && valAnt) { // transicion de 1 a 0 de NO a NC
Serial.println(“Sinfin detenido”); // Muestra dicha transición en el monitor serial
digitalWrite(LED1,LOW); //Apaga LED1

digitalWrite(LED2,HIGH); //Enciende LED2
sinfin.write(0);
}
valAnt = val; //Iguala los valores anteriores y actuales de val
}

long ultrasonico(int trigger, int echo) {
long duration2, distance2; //ajusta segundo sensor

digitalWrite(trigger, LOW); //desactiva pin2
delayMicroseconds(2); // espera dos micrsegundos
digitalWrite(trigger, HIGH); //activa el pin 2
delayMicroseconds(10); // espera 10 microsegundos
digitalWrite(trigger, LOW); //desactiva pin2
duration2 = pulseIn(echo, HIGH); //calcula la duración de la señal
distance2 = (duration2/2) / 29.1; //calcula la distancia
return distance2;
}

long ultrasonico2(int trigger, int echo) {
long duration1, distance1; //ajusta segundo sensor

digitalWrite(trigger, LOW); //desactiva pin2
delayMicroseconds(2); // espera dos micrsegundos
digitalWrite(trigger, HIGH); //activa el pin 2
delayMicroseconds(10); // espera 10 microsegundos
digitalWrite(trigger, LOW); //desactiva pin2
duration1 = pulseIn(echo, HIGH); //calcula la duración de la señal
distance1 = (duration1/2) / 29.1; //calcula la distancia
return distance1;

}

Amigo Ricardo.
Para que veas que si te puse atención en tus explicaciones que me hiciste el favor de hacerme ayer.
ya resolví el problema que generaba el flotador gracias a tus explicaciones.

de nuevo gracias por tu ayuda.
Saludos.

código resuelto.

#include <Bounce2.h> //Librería anti rebote.

#define FLOTA_PIN 3 //Flotador en el pin 3

#define BOMBA_PIN 9 // Bomba de agua en el pin 9

// Crea la instancia del rebote
Bounce debouncer1 = Bounce();

void setup() {

// Configura el flotador como botón pull up
pinMode(FLOTA_PIN,INPUT_PULLUP);
// Configura la instancia de rebote :
debouncer1.attach(FLOTA_PIN);
debouncer1.interval(5); // intervalo en milisegundos

//Configura bomba de agua como salida :
pinMode(BOMBA_PIN,OUTPUT);

}

void loop() {
// Actualiza los rebotes :
debouncer1.update();

// Toma el valor actualizado :
int value1 = debouncer1.read();

// Apaga la bomba si el flotador esta en LOW
if ( value1 == LOW ) {
digitalWrite(BOMBA_PIN, LOW );
}
else {
digitalWrite(BOMBA_PIN, HIGH ); //Enciende la bomba si el flotador esta en HIGH
}

}