Acuariofilia Madrid

Páginas: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119

Parece que estamos de vacaciones, no?

Buenos dias.
Antonio, tengo una duda sobre el tema de los leds y su voltaje de alimentación. Creo que ya comentaste algo, pero quiero confirmarlo.

Te pongo en antecedentes;

-Una fuente de alimentación regulada a 11,4 voltios de salida.
-Leds verdes, 350mA, voltaje de alimentación 3,2 a 3,4v.
-Leds rojos, 350mA, voltaje de alimentación 2,0 a 2,6v.

La pregunta: ¿Es posible montar una linea de 2 rojos + 2 verdes?.

Gracias por tu atención.

Teniendo en cuenta la tension de los led ....
dos rojos ...2,6*2 =5,2v
dos verdes ... 3,4*2 = 6,8v

total ... 12V.
Ese seria al maximo de su funcionamiento
Al minimo serian unos 10,4V ...

Con una resistencia limitadora de 3,3 ohmios y de 0,5W podrias hacerlos funcionaren el limite bajo sin problemas. Pero no van a darte el tope de luminosidad.

Ok, gracias Namiga.

Si la fuente la regulo a 11,4 V, no se dañaran por sobretensión los leds rojos?

(27-08-2014, 07:57 AM)xavi escribió: [ -> ]Buenos dias.
Antonio, tengo una duda sobre el tema de los leds y su voltaje de alimentación. Creo que ya comentaste algo, pero quiero confirmarlo.

Te pongo en antecedentes;

-Una fuente de alimentación regulada a 11,4 voltios de salida.
-Leds verdes, 350mA, voltaje de alimentación 3,2 a 3,4v.
-Leds rojos, 350mA, voltaje de alimentación 2,0 a 2,6v.

La pregunta: ¿Es posible montar una linea de 2 rojos + 2 verdes?.

Gracias por tu atención.

Respuesta breve: Si.

Respuesta larga:
En un montaje de elementos en serie sean LEDs o cualquier otra cosa, circulará siempre la misma intensidad, en este caso no hay problema, coinciden. La diferencia de potencial en el total de esa línea será la suma de las caídas de potencial provocada por cada uno de los LEDs que cuando son distintos no tienen por qué coincidir.

(27-08-2014, 08:48 AM)xavi escribió: [ -> ]Ok, gracias Namiga.

Si la fuente la regulo a 11,4 V, no se dañaran por sobretensión los leds rojos?

Solo debes de preocuparte del voltaje total. Calculando el voltaje máximo admisible y el mínimo. Te da que 11,4 está dentro de ambos límites.

Los cálculos de Namiga para los voltajes totales son correctos.

(3.2*2)+(2*2) =10.4
(3.4*2)+(2.6*2) =12.0

Pero la conclusión no lo es porque eso significa que en esa linea no necesitas poner ninguna resistencia y que todos los LEDs van a recibir un voltaje dentro de su respectivo rango de trabajo y que la corriente que va a circular será 350mA en todos ellos.

Ok, gracias a ambos.

Hola Antonio. Estoy programando el abono de forma automática mediante el arduino sin embargo a veces en lo más sencillo es en lo que uno se atasca. Te explico lo que quiero hacer:

Utilizaré dos depósitos uno uno para el potasio y el otro ya lo veré más adelante. Mi idea es hacer funcionar los dosificadores a una hora determinada durante 5 segundos un dia si, un dia no y de forma contraria. Es decir, si un dia se conecta el motor 1 a las 14:00 y permanece encendido durante 5s, al día siguiente a las 14:00 se conecta el motor 2 durante 5 segundos, el tercer día se conecta el 1 otra vez, etc. La única forma que se me ocurre es con el valor de retorno de millis() pero teniendo en cuenta que el reloj solo me permite tener una precisión de encendido y apagado de 1 min, no se como hacerlo

Gracias

Hablas de motores que no sé lo que hacen. Creo que son dos dosificadores en días alternos y que los motores funcionarán 5 segundos para distribuir una dosis. Tampoco entiendo que digas que el reloj tiene una precisión de un minuto. Ignoro si la distribución es por goteo, supongo que sí, o quizás sea de otra forma. Comenta un poco los mecanismos de los dosificadores. Me parece un tema muy interesante y me encantará ayudarte.

Buenos días.

Pon el enlace al tipo de motor / bomba perilstatica que tienes en mente.

5 segundos implica que utilizas una mezcla de abono muy concentrada, y puede ser que la bomba no sea tan precisa, o que factores externos ( aire en los tubos, etc) haga que la dosis de abono sea errática.

Sin entrar en tema Arduino, yo diluiría mas el abono, para dosificar mas cantidad/tiempo. No se si me explico.

Y también depende del consumo del acuario de NPK y de los factores que implica ello..

Vale sé lo que es una bomba peristáltica. Son una pasada.
Si las dosis son cada dos días dudo que se necesite una dosis precisa. El promedio sería lo que hay que regular. A falta de un sistema que controle el número de giros habrá que vigilar que la bomba peristáltica mantenga su efectividad, pero supongo que con un adecuado mantenimiento son instrumentos fiables y precisos y que controlar el tiempo puede ser suficiente.

Si no tienes RTC se podría teoricamente usarse millis que cuenta los milisegundos, pero para ciertos casos hay que tener mucho cuidado al usar millis(). Esta función devuelve el número de milisegundos desde que arrancó Arduino, pero cada 49 días y pico, el contador alcanza su máximo y vuelve a cero. Si no se programa una función que lo tenga en cuenta podría ocurrir que después de casi dos meses funcionando correctamente el dosificador se vuelva loco y no se detenga. En programación el diablo está en los detalles.

Ignoro que tipo de control se va a hacer. Si el control es de tipo manual haciendo analíticas cada cierto tiempo habrá que contemplar la posibilidad de ajustar la dosis mediante incrementos o disminuciones de los tiempos de bombeo. Esto ha de guardarse en la EEPROM porque si hacemos un ajuste manual, debe conservarse la misma dosis aunque ocurra un breve corte de luz que reinicie el sistema.

Mi módulo de parametros podría servir muy bien para eso.

Me encanta que surjan nuevos temas relativos necesidades de automatización.

Hola a todos. Con motor me refiero a bomba de dosificación. Pensé en ponerla peristática pues es mucho más precisa pero tiene dos inconvenientes: el precio y el aire que se acumula en los tubos. Con lo segundo me refiero a que con un dosificador no peristático, una vez que se corta el motor, el liquido que había en el tubo baja de nuevo al depósito. con una peristática es mucho más lento e impredecible el vaciado del tubo. Si el tubo esta vacío completamente, puedo asegurarme que siempre suba la misma cantidad de abono al acuario. El motor dosificador al que me refiero es este:

[Imagen: DC-12V-Dosing-pump-Peristaltic-dosing-He...ipping.jpg]

[Imagen: DC-12V-Dosing-pump-Peristaltic-dosing-He...ipping.jpg]

Solo lo enciendo 5s porque tiene un caudal bastante grande que ya estoy pensando en regular poniendo una T a la salida de este. Una salida va al acuario y la otra vuelve al depósito del abono, consiguiendo así una reducción del caudal y que el abono del recipiente se remueva.

Con lo de la precisión de un minuto me refiero a que en mi sketch yo uso la función if(Reloj.IsLater(10, 2) && Reloj.IsPrevious(19, 15)){......} ¿hay alguna otra forma de poder programar durante 5s algo? Publico mi sketch en unos minutos con los comentarios que pueda para que no sea tan lioso

Un saludo

Código PHP:
#include <DallasTemperature.h>
#include <OneWire.h>
#include <RelojDS1307.h>
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

unsigned long estadoprevio=0;
boolean repeticion=1;

//creamos las variables para las funciones de encendido manual y apagado
boolean botonmanual10=0;
boolean botonmanual1=0;
int sumamanual=0;//se utilizará para hacer 2 comprobaciones de boton manual
boolean botonoff10=0;
boolean botonoff1=0;
int sumaoff=0;//se utilizará para hacer 2 comprobaciones de boton apagado

int boton3ultimo=0;
int boton3actual=0;
int contador=0;

boolean boton4=0;


#define TEMP           22
#define ULTRASONI      23
#define BUZZER         7
#define rele3          34
#define ABONO1         30 
#define ABONO2         31
#define BOMBA          33
#define LUZPANT        32
#define VENT           35


LiquidCrystal_I2C lcd(0x27,20,4);
OneWire oneWire(TEMP);
DallasTemperature sensors(&oneWire);
DeviceAddress ACUARIO;
DeviceAddress PANTALLA;
RelojDS1307Class Reloj;

byte bat1[8] = {B01110,B11011,B10001,B10001,B10001,B10001,B10001,B11111
};
byte bat2[8] = {B01110,B11011,B10001,B10001,B10001,B11111,B11111,B11111
};
byte bat3[8] = {B01110,B11011,B10001,B11111,B11111,B11111,B11111,B11111
};
byte bat4[8] = {B01110,B11111,B11111,B11111,B11111,B11111,B11111,B11111
};

void setup(){
  
 lcd.init();
 lcd.backlight();
 lcd.createChar(2, bat1);
 lcd.createChar(3, bat2);
 lcd.createChar(4, bat3);
 lcd.createChar(5, bat4);
  
 pinMode(BUZZER,OUTPUT);
 pinMode(VENT, OUTPUT);
 pinMode(LUZPANT, OUTPUT);
 pinMode(ABONO1, OUTPUT);
 pinMode(ABONO2, OUTPUT);
 pinMode(BOMBA, OUTPUT);
 pinMode(rele3, OUTPUT);
 pinMode(40, INPUT);//botonmanual
 pinMode(41, INPUT);//botonoff
 pinMode(42, INPUT);//boton2
 pinMode(43, INPUT);//boton3
 pinMode(44, INPUT);//boton4
 
 Serial.print("Localizando sondas de temperatura: ");
 Serial.print("Encontradas  ");
 Serial.print(sensors.getDeviceCount(), DEC);
 Serial.println(" sondas.");
 
 digitalWrite(BOMBA,LOW);
 digitalWrite(VENT,HIGH);
 digitalWrite(ABONO1,HIGH);
 digitalWrite(ABONO2,HIGH);
 digitalWrite(LUZPANT,LOW);
 digitalWrite(BUZZER,LOW);
 digitalWrite(rele3,HIGH);
 
 
 lcd.setCursor(4,0);
 lcd.print("HOLA ALBERTO");
 lcd.setCursor(5,3);
 lcd.print("PLABOT V2");
 delay(2000);
 lcd.setCursor(5,1);
 lcd.print("condensador");
 lcd.setCursor(3,1); lcd.write(2);delay(tiempo);
 lcd.setCursor(3,1); lcd.write(3);delay(tiempo);
 lcd.setCursor(3,1); lcd.write(4);delay(tiempo);
 lcd.setCursor(3,1); lcd.write(5);delay(tiempo);
 lcd.setCursor(3,1); lcd.write(2);delay(tiempo);
 lcd.setCursor(3,1); lcd.write(3);delay(tiempo);
 lcd.setCursor(3,1); lcd.write(4);delay(tiempo);
 lcd.setCursor(3,1); lcd.write(5);delay(tiempo);
 delay(1500);
 lcd.clear();
 lcd.setCursor(6,1);
 lcd.print("¡LISTO!");
 delay(1500);
 lcd.clear();
}


void loop(){
  Serial.begin(9600);
  sensors.requestTemperatures();
  printTemperature(ACUARIO);
  
  digitalWrite(BOMBA,HIGH);
  digitalWrite(ABONO1,HIGH);
  digitalWrite(ABONO2,HIGH);
  lcd.setCursor(6,2);
  lcd.print("PUMP:SI");
  lcd.setCursor(14,2);
  lcd.print("K:NO");
  lcd.setCursor(14,3);
  lcd.print("Fe:NO");

  float AGUA1 = sensors.getTempC(ACUARIO);
  
  if(AGUA1 <= 28.8){
    digitalWrite(VENT,HIGH);
    lcd.setCursor(1,2);
    lcd.print("V:NO");
  }
  
  if(AGUA1 >= 29){
    digitalWrite(VENT,LOW);
    lcd.setCursor(1,2);
    lcd.print("V:SI");
  }
  
  if(AGUA1 >= 32){
    tone(BUZZER,3000);
    delay(2500);
    noTone(BUZZER);  
  }  
   else if(AGUA1 <= 21){
      tone(BUZZER,3000);
      delay(2500);
      noTone(BUZZER);
    } 
     else{
       noTone(BUZZER);
     }

    
    
  apagado(ACUARIO);
  abonado(ACUARIO);
  manual (ACUARIO);
  contador=0;//volvemos a poner el contador manual a 0
  apagado (ACUARIO);
  contador=0;//volvemos a poner el contador apagado a 0
  
  //programados la luz de la pantalla que posee un chip de reducción a 4 cables. Un relé esta conectado a los pines de la luz
  if(Reloj.IsLater(9, 00) && Reloj.IsPrevious(22, 00)){
    digitalWrite(LUZPANT,LOW);
  }
   else{
     digitalWrite(LUZPANT,HIGH);
   }
  
  if(Reloj.IsLater(00, 00) && Reloj.IsPrevious(7, 00)){
    lcd.noDisplay();
  }
   else{
    lcd.display();
   }
  
    

 //mostramos un fallo en caso de un fallo en la sonda
if (!sensors.getAddress(ACUARIO, 0))
 { 
  Serial.println("INCAPAZ DE ENCONTRAR SONDA ACUARIO");
  lcd.setCursor(0,1);
  lcd.print("FALLO S1"); 
 } 
 
   if (sensors.getAddress(ACUARIO, 0))
 { 
  lcd.setCursor(0,1);
  lcd.print("S1--OK");
 } 
  
} 

//mediante void manual cuando pulso el boton del pin 41, me saldrá un menú en el que 
//mediante el número de pulsaciones del pin 42, puedo poner en modo manual (encendido) 
//los distintos elementos
void manual (DeviceAddress deviceAddress){
  botonmanual10=digitalRead(41);//hacemos dos comprobaciones del boton 41 y comprobamos lo que da la suma de ambas 
  delay(tiempo1);
  botonmanual1=digitalRead(41);
  sumamanual=botonmanual10+botonmanual1;
  if (sumamanual==2){
    lcd.clear(); }
  while(sumamanual==2){
    opciones(ACUARIO);
    boton3actual=digitalRead(42);
    if (boton3actual != boton3ultimo){
      if (boton3actual == HIGH) {
       contador = contador + 1;
      }  
    }
    boton3ultimo= boton3actual;
    switch (contador){
      case 1:
       lcd.setCursor(19,0);
       lcd.print("1");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(BOMBA,HIGH);
       }
      break;
      case 2:
       lcd.setCursor(19,0);
       lcd.print("2");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(ABONO1,LOW);    
       }
      break;
      case 3:
       lcd.setCursor(19,0);
       lcd.print("3");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(ABONO2,LOW);
       }
      break;
      case 4:
       lcd.setCursor(19,0);
       lcd.print("4");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(VENT, LOW);
       }
      break;
      case 5:
       lcd.setCursor(19,0);
       lcd.print("5");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(LUZPANT,LOW);
       }
      break;
      case 6://salimos a la pantalla principal
       lcd.setCursor(19,0);
       lcd.print("6");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       sumamanual=3;
       lcd.clear();
       }
      break;
      default:
       lcd.setCursor(19,0);
       lcd.print("-");
       contador=0;
    }
  }
  }    

//mediante void apagado cuando pulso el boton del pin 44, me saldrá un menú en el que 
//mediante el número de pulsaciones del pin 42, puedo poner en modo apagado
//los distintos elementos  
void apagado (DeviceAddress deviceAddress){
  botonoff10=digitalRead(44);
  delay(tiempo1);
  botonoff1=digitalRead(44);
  sumaoff=botonoff10+botonoff1;
  if (sumaoff==2){
    lcd.clear(); }
  while(sumaoff==2){
     opciones(ACUARIO);
     boton3actual=digitalRead(42);
     if (boton3actual != boton3ultimo){
      if (boton3actual == HIGH) {
       contador = contador + 1;
      }  
     }
     boton3ultimo= boton3actual;
     boton4=digitalRead(43);
     switch (contador){
      case 1:
       lcd.setCursor(19,0);
       lcd.print("1");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(BOMBA,LOW);
       }
      break;
      case 2:
       lcd.setCursor(19,0);
       lcd.print("2");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(ABONO1,HIGH);    
       }
      break;
      case 3:
       lcd.setCursor(19,0);
       lcd.print("3");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(ABONO2,HIGH);
       }
      break;
      case 4:
       lcd.setCursor(19,0);
       lcd.print("4");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(VENT, HIGH);
       }
      break;
      case 5:
       lcd.setCursor(19,0);
       lcd.print("5");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       digitalWrite(LUZPANT,HIGH);
       }
      break;
      case 6://vuelvo a la pantalla principal
       lcd.setCursor(19,0);
       lcd.print("6");
       boton4=digitalRead(43);
       if(boton4==HIGH){
       sumaoff=3;
       lcd.clear();
       }
      break;
      default:
       lcd.setCursor(19,0);
       lcd.print("-");
       contador=0;
    }
  }
}
    
//este es el menú que sale en void manual o apagado    
void opciones (DeviceAddress deviceAddress){
   lcd.setCursor(2,0);
   lcd.print("ALBERTO,elige");
   lcd.setCursor(1,1);
   lcd.print("1.BOMBA");
   lcd.setCursor(1,2);
   lcd.print("2.K2SO4");
   lcd.setCursor(1,3);
   lcd.print("3.Fe");
   lcd.setCursor(10,1);
   lcd.print("4.VENT");
   lcd.setCursor(10,2);
   lcd.print("5.PANT");
   lcd.setCursor(10,3);
   lcd.print("6.SALIR");
   
}

//este es mi intento del abonado. Algo lioso y dificil de entender pero lo importante
//es que no funciona
void abonado(DeviceAddress deviceAddress){
  unsigned long retardo=0;
  unsigned long retardo1=0;
  if(millis()!=86400000){
    if(Reloj.IsLater(14, 37) && Reloj.IsPrevious(14, 39)){
      if(millis()*estadoprevio==0){
        estadoprevio=millis();
     }
    }
    if(millis()-estadoprevio==86400000){
      retardo=millis();
      lcd.clear();
      while(retardo+5000>=millis()){
        digitalWrite(ABONO1,LOW);
        lcd.setCursor(3,1);
        lcd.print("DOSIFICANDO");
        lcd.setCursor(9,2);
        lcd.print("Fe");
        estadoprevio=0;
      }
      lcd.clear();
      digitalWrite(ABONO1,HIGH);
      lcd.setCursor(14,3);
      lcd.print("Fe:NO");
      lcd.setCursor(1,0);
      lcd.print(Reloj.DateTime());
     }
  } 
      
  if(Reloj.IsLater(14, 34) && Reloj.IsPrevious(14, 36)){
    if(repeticion!=0){
     if(estadoprevio==0){
       retardo1=millis();
       lcd.clear();
       while(retardo1+5000>=millis()){
         digitalWrite(ABONO2,LOW);
         lcd.setCursor(3,1);
         lcd.print("DOSIFICANDO");
         lcd.setCursor(7,2);
         lcd.print("K2SO4");
         
       }
      repeticion=0;
      lcd.clear();
      digitalWrite(ABONO2,HIGH);
      lcd.setCursor(14,2);
      lcd.print("K:NO");
    }
    }
  }
  else{
   repeticion=1;
  }
}

//esto todavía no lo tengo terminado
void ultrasonidos (DeviceAddress deviceAddress){
  int distancia;
  unsigned long tardanza=0;
  pinMode(ULTRASONI,OUTPUT);
  digitalWrite(ULTRASONI,LOW);
  delayMicroseconds(5);
  digitalWrite(ULTRASONI,HIGH);
  delayMicroseconds(5);
  digitalWrite(ULTRASONI,LOW);
  pinMode(ULTRASONI,INPUT);
  tardanza=pulseIn(ULTRASONI,HIGH);
  tardanza=tardanza/2;
  distancia=int(0.034*tardanza);
  lcd.setCursor(0,3);
  lcd.print("NIVEL:");
  lcd.setCursor(7,3);
  lcd.print(distancia);
}
  
  
//mostramos las temperaturas y la hora  
void printTemperature(DeviceAddress deviceAddress)
{
  float AGUA1 = sensors.getTempC(ACUARIO);
  Serial.print("ACUARIO: ");
  Serial.print(AGUA1);
  Serial.print("  ");
  lcd.setCursor(1,0);
  lcd.print(Reloj.DateTime());
  lcd.setCursor(7,1);
  lcd.print("TEMP:");
  lcd.print(AGUA1);
} 

gracias

No me he descargado la librería #include <RelojDS1307.h> pero en Portal Pez (Controlador de acuario electrónico con Arduino) Dukatus publica la descripción de las funcionalidades de librería.

void SetDateTime( int monthDay, int month, int year, int hour, int minute, int second );//Establece la la fecha y hora del reloj
void GetDateTime( int &monthDay, int &month, int &year, int &hour, int &minute, int second );//Obtiene la fecha y hora en parametros separados.
char * DateTime();//Obtiene una cadena de texto con la fecha y la hora.
char * Date();//Obtiene una cadena de texto con la fecha.
char * Time();//Obtiene una cadena de texto con la hora y minutos.
int GetHour();//Obtiene un entero con el valor de la hora.
int GetMinute();//Obtiene un entero con el valor de los minutos.
int GetYear();//Obtiene un entero con el valor del año.
int GetMonth();//Obtiene un entero con el valor del mes.
int GetDay();//Obtiene un entero con el valor del día.
void SetDiaSemana( int DiaSemana ); //Establece el día de la semana(Lunes,Martes….).
int GetDiaSemana(); //Obtiene un entero con el valor del día de la semana
char * DiaName(); //Obtiene una cadena con el nombre del día de la semana.
char * MesName();//Obtiene una cadena con el nombre del mes.
boolean IsLater( int hour, int minute ); //No devuelve si la hora actual es mas tarde que la pasada.
boolean IsPrevious( int hour, int minute ); //No devuelve si la hora actual es mas temprana que la pasada.

Me temo que es una librería a la cual le faltan algunas funcionalidades que me parecen muy necesarias y por el contrario incluye algunas funciones que no vienen demasiado a cuento.

Por ejemplo: No le veo el sentido a una función SetDiaSemana() porque se presta a inconsistencias.
El día de la semana debe venir calculado a partir de la fecha y no es correcto dar opción a modificarlo.

Tampoco me parece elegante usar funciones del tipo IsLater() IsPrevious() son funciones que no se usan porque se suele usar la funcion UnixTime() que sirve para eso y para mucho más.

Probablemente el que hizo la librería no necesitaba gestionar los segundos.

Yo también he diseñado mi propia librería para RTC pero dada su complejidad he procurado no complicarme y me he basado en la "RTClib.h" de JeeLabs http://news.jeelabs.org/code/ (un Krack).

Tengo mi propia librería RTC porque necesitaba añadir algunas funcionalidades y necesitaba que se comunicara con mi interfaz de usuario (LCD, buzzer) para por ejemplo mostrar mensajes de error.

La función UnixTime() no debe faltar en ninguna librería de RTC. La mayoría de los sistemas informáticos la usan. Es un función estandar POSIX omnipresente. Veasé Tiempo Unix

Al ser UnixTime() el número de segundos transcurridos desde la medianoche UTC del 1 de enero de 1970, se representa con un dato numérico del tipo unsigned long y para saber si un momento es anterior o posterior a otro basta compararlos, o calcular la diferencia que vendrá dada en segundos.

Lo que quiero decir, es que tengo serias dudas sobre el uso de esta librería "RelojDS1307" para lo que tú necesitas.

Las soluciones son tres:
1) Hacer una ampliacion de esa librería para gestionar segundos.
2) Usar una librería más completa como la "RTClib.h" de JeeLabs y adaptarla a tus necesidades que es lo que hice yo.
3) Usar funciones basadas en millis() y que corrigen el posible efecto de desbordamoiento tras 49 días.

La segunda va a suponer retocar toda tu aplicación, pero a pesar de ello probablemente resulte lo más fácil y desde luego que el resultado final será mejor, y si necesitas nuevas funcionalidades te será mucho más fácil. Hay que tener en cuenta que la programación de una librería del tipo RTClib, no tiene nada de trivial. Necesita de unos conocimientos técnicos muy considerables. De hecho me metí en camisa de once varas y tuve ceñirme bastante a la librería original de JeeLabs.

La tercera te puede valer si solo necesitas esa funcionalidad nueva, pero la segunda es más completa y aunque exige más tiempo no te va a limitar en un futuro tanto como las otras.

PD:
Una de las cosas que me gustaría hacer es implementar la posibilidad de gestionar horas locales con los cambios de horarios verano/invierno pero me temo que ni JeeLabs se atrevió a hacerlo, aunque seguro que en algún sitio vendrá explicado como puede hacerse. Meterse en ciertos líos de programación necesita bastante dedicación.

Respecto al motorcillo:
Para la reducción del caudal podrías usar una reductura de endranajes. Me gustaría que me indicaras una referencia a ese producto, porque me parece interesante.,

Una bomba de ese tipo no podría regularse mediante PWM?

Es una carga inductiva y no he visto muchos circuitos para regular cargas inductivas con PWM. Supongo que eso se debe a que (a diferencia de los LEDs) cada circuito inductivo tiene una determinada impedancia que afecta al diseño del mismo pero también he visto circuitos relativamente sencillos. Yo investigaría en Google buscando por: PWM "carga inductiva" mosfet

xavi

xavi

Namiga

xavi

Antonio Castro

xavi

albertoespinosa

Antonio Castro

xavi

PECES TROPICALES

Antonio Castro

albertoespinosa

Antonio Castro

xavi

Antonio Castro