Sincronizar dos electroválvulas

En este momento tengo una placa Arduino duamilanove que controla una electroválvula, la cuestión es saber si ¿hay alguna forma de conseguir que al conectar una segunda electroválvula la emisión de liquido se sincronicen, es decir que caigan al mismo tiempo? El problema está que la electroválvula lo que hace es emitir una gota cada cierto tiempo y el código lo que hace es enviar la orden de forma secuencial (según entiendo) con lo cual las gotas de ambas caen en tiempos distintos, lógicamente con una separación de tiempo mínima pero existente, ¿hay alguna forma de solucionarlo?

Hola Antonio,

Tal como entiendo el problema, creo que no debes preocuparte demasiado.

Si no me equivoco debes tener un a parte de código parecido a esto:

digitalWrite(valvula1, HIGH); digitalWrite(valvula2, HIGH);

Si, es cierto que la activación es seqüencial: primero se abrirá una y después la otra. El caso es que la mecànica de fluidos no es instantanea y los retardos que se te pueden producir por otros efectos físicos (capilaridad, presión del fluido, reacción de la electrovàlvula...) seguramente serán mayores que el retardo entre instruciones (si no me salen mal las cuentas por debajo de 1 microsegundo).

Un saludo,

Tal vez sea falta de como funciona el sistema, pero veo la dificultad en que no es una secuencia en la cual la primera electroválvula emita una sola gota y luego la segunda. Para clarificarlo pongo un ejemplo: La primera electroválvula tiene que emitir dos gotas y entre una y otra esperar, por ejemplo 100 ms. y exactamente igual tiene que hacer la segunda electroválvula. Entiendo que internamente el funcionamiento seria: Primera electroválvula emite la primera gota Segunda electroválvula emite la primera gota Primera electroválvua emite la segunda gota Segunda electroválvula emite la segunda gota y así sucesivamente Si estamos trabajando con tiempos de milisegundos en la frecuencia de caida, este control entre una y otra electroválvula ¿será insignificante? gracias.

Creo que el problema no va a ser por culpa de arduino.... Arduino te permite temporizar a nivel de microsegundos: http://arduino.cc/en/Reference/DelayMicroseconds o milisegundos: http://arduino.cc/en/Reference/Delay

¿Te has fijado si el ciclo de trabajo máximo de las electroválvulas te permite abrir y cerrar 10 veces por segundo?

Un saludo.

La electroválvula no tiene problema en ese sentido, puede emitir una gota cada 20 ms.

Vale. La válvula va a poder :)

De todos modos no acabo de verle el sentido.... Confirmame si este es el tema: la VALVULA_1 y la VALVULA_2 deben producir gotas cada X milisegundos (pongamos 100ms) y las dos deben producir las gotas..... ¿al mismo tiempo exactamente? ¿Por cada gota de VALVULA_2 deben haber dos gotas de VALVULA_1? ¿....?

Me gusta la aplicación. ¿Que tiempo debes tener activadas las Electroválvulas para producir una sola gota?

¿Y por qué no conectas ambas válvulas a la misma fuente de señal?

La secuencia puede variar, porque habrá momentos que efectivamente ambas tengan que emitir al unísono las mismas gotas, con la misma frecuencia, en otros caso es posible que la configuración sea distinta para cada una, comenzando una antes que otra. A tu pregunta concreta, para formarse una gota los tiempos pueden ir desde 20 o 30 ms. hasta 100 ms (aproximadamente)

Para dejar mas claro, pongo dos unos ejemplos que pueden demostrar la flexibilidad que se necesita en su configuración:

Primer caso: Ambas electroválvulas a la vez tienen que emitir dos gotas cada una, para ello la electroválvula está abierta durante 70 ms. y entre la primera y la segunda gota debe haber una demora de 90 ms.

Segundo caso: La primera electroválvula permanece abierta para formar una gota durante 80 ms y emite la gota, a continuación, a los 10 ms. de emitirse esta primera gota, la segunda electroválvula debe emitir una gota para lo cual configuramos 80ms. para formarse. Podríamos decir que a continuación vuelve a emitir la primera o cualquier otra variación.

Es decir… que en el segundo caso a los 10ms de que la gota de la valvula_1 empieza a formarse, en la valvula _2 debe empezar a formarse otra gota, para que caiga la gota #2 10ms. después de la #1, habiendo pasado 80ms para la formación de las dos gotas. ¿Es así?

(Cada vez me gusta mas :slight_smile: )

Efectivamente, es solo un ejemplo, pues lógicamente los tiempos como digo pueden variar dependiendo de como se quiera la gota, es decir tenemos un parámetro de formación de gota: una gota pequeñita tendria un tiempo de formación de 20ms. y una gorda tendría, digamos un tiempo de 90 ms. Otro parámetro seria el número de gotas y el último parámetro sería el retardo entre una gota y otra. Y estos tres parámetros serían para cada electroválvula. Un motivo por el cual no se puede usar la misma señal es porque cada una tiene una configuración distinta, pero además hay otro motivo y es que si ambas electroválvulas no tienen las mismas caracteristicas la única forma de sincronizarlas es configurando estos parámetros.

Entonces usa un latch

Perdona Chiva, ahí me pierdo, como es ese sistema?

Ya veo cual es el problema. Pero puedes resolverlo con Arduino.....

Tal como dices, necesitas manejar 6 variables (3 por válvula), 4 de las cuales són en función del tiempo. Como los tiempos entre una válvula y la otra pueden solaparse no puedes usar el mètodo de delay(), ni delaymicroseconds() , sino que se deberia emplear la consulta hacia la función millis() o micros(), de forma similar al sketch de ejemplo del IDE "BlinkWithoutDelay".

Es decir, comprobar en cada pasada del loop si se cumple alguno de los criterios de tiempo para abrir o cerrar alguna de las válvulas. Si se cumple, pués haces lo que convenga,¿que no? pués otra vuelta al loop() sin hacer nada.

AntonioT

Porque no programas apriori, los inicios y finales de las gotas (Microsegundos o Milisegundos) y despues los comparas con los Milisegundos de arduino y haces lo que corresponda…

Ejemplo:

Abrir gota_1 (milisegundo 25)
Abrir gota_2 (milisegundo 30)
Cerrar gota_2 (milisegundo 50) // Una de tus gotas pequeñas
Abrir gota_2 (milisegundo 70)
Cerrar gota_1 (milisegundo 75) // Una gota gorda…
Cerrar gota_2 (milisegundo 90) // Otra Pequeña…

Entre gota y gota tendrías que programar el inicio y final de la siguiente…

Claro está que el programa tiene que ser lo suficientemente pequeño para que pueda correr mucho…

piniflopa... he dicho lo mismo... pero he tardado más en escribirlo!!! ;)

Aun usando delay se podría realizar perfectamente.

De todas formas por si sirve, me equivoqué al decir latch en verdad era un biestable tipo D: http://es.wikipedia.org/wiki/Biestable#Biestable_D_.28Delay.29

Le metes en la entrada la señal que quieras y cuando activas C, aparece el valor de D en la salida de la derecha, por lo que si usas varios en paralelo, los puedes activar exactamente a la vez.

También podrías usar registros de desplazamiento, que al final son varios biestables D en cascada: http://es.wikipedia.org/wiki/Registro_de_desplazamiento

Un saludo

Podrías utilizar la manipulación directa de los puertos http://www.arduino.cc/en/Reference/PortManipulation

Con esto te aseguras que se activan las dos electroválvulas o lo que quieras al mismo tiempo.

Con la función millis debe ser suficiente. (Ejemplo blink without delay). Yo estoy trabajando con 20 valvulas en un loop similar sin problemas de retardos de tiempos..

Lo que te sugiero es que inicies con el Blink without delay para 1 gota, modificale los parametros y ya que entiendas el funcionamiento repite el codigo para la segunda gota y listo.

El código con el que estoy trabajando es este:

#define PIN_VALVULA1   10  //Utilizamos el Pin 10 para conectar la electroválvula 1
#define PIN_VALVULA2   9  //Utilizamos el Pin 9 para conectar la electroválvula 2
#define PIN_PULSADOR  8  //Utilizamos el Pin 8 para controlar un pulsador

#define TIEMPO_GOTA1          70    
#define TIEMPO_ENTRE_GOTAS1   118  

#define TIEMPO_GOTA2          70    
#define TIEMPO_ENTRE_GOTAS2   118 

void setup(){
  
  pinMode(PIN_VALVULA1, OUTPUT);
   pinMode(PIN_VALVULA2, OUTPUT);
  pinMode(PIN_PULSADOR, INPUT); 

}

void loop(){

  if(digitalRead(PIN_PULSADOR)) {
    
     for (int i=0; i<2; i++) {         //Definimos el número de gotas 
        digitalWrite (PIN_VALVULA1, HIGH); 
        digitalWrite (PIN_VALVULA2, HIGH);
        delay(TIEMPO_GOTA1);     
        delay(TIEMPO_GOTA2);      
        digitalWrite(PIN_VALVULA1,LOW);
        digitalWrite(PIN_VALVULA2,LOW);
        delay (TIEMPO_ENTRE_GOTAS1);
        delay (TIEMPO_ENTRE_GOTAS2);
        
        
     }  
  }
}

La interpretación que yo hago de estas líneas (corregirme si me equivoco) :
digitalWrite (PIN_VALVULA1, HIGH);
digitalWrite (PIN_VALVULA2, HIGH);
delay(TIEMPO_GOTA1);
delay(TIEMPO_GOTA2);
digitalWrite(PIN_VALVULA1,LOW);
digitalWrite(PIN_VALVULA2,LOW);
delay (TIEMPO_ENTRE_GOTAS1);
delay (TIEMPO_ENTRE_GOTAS2);

Una vez activadas las electroválvulas, si TIEMPO_GOTA1 se le suma el tiempo de demora de TIEMPO_GOTA2 si el proceso es secuencial se estan sumando ambos tiempos y por lo tanto no se cumple la condición y al final del proceso la secuencia lo que hace es emitir primero la GOTA1 y posteriormente la GOTA2 con lo cual ambas gotas no van a caer al mismo tiempo.

El DELAY es una pausa de milisegundos en el programa, de tal modo que, como tu tienes 2 delays seguidos entonces la pausa durara la suma de ambos delays. Lo que hace tu programa es: Abre válvula 1. Abre válvula 2. Hace una pausa de 70 ms. (Delay tiempo_gota1) Hace otra pausa de 70 ms. (Delay tiempo_gota2) Cierra valvula 1. Cierra valvula 2. Hasta aqui, el resultado es que las válvulas permanecen abiertas 140. Hace una pausa de 180 ms. (Delay tiempo_gota1) Hace otra pausa de 180 ms. (Delay tiempo_gota2) Es decir, las válvulas han permanecido cerradas durante 360. Por lo tanto las válvulas están abriendo y cerrando al mismo tiempo.