error en codigo para control de nurientes

hola amigos gracias por sernos de tanta ayuda en tantas ocasiones, esta es mi primera ver que posteo ya que mis dudas siempre las mitigue en google youtube y por aquí con circunstancias parecidas. pero ahora tengo uno proyecto en desarrollo y me esta dando problemas el codigo que escribí, fue consultando, copiando de allí rebuscando de acá se trata de un arduino con sensores que miden diferentes parámetros para la concentración de elementos y calidad de agua y el codigo se me esta atragantado entre mis fallas de sintaxis falta de comprension de articulos, el codigo es el siguiente.

#include <Wire.h>
#include <DS3232RTC.h>
#include <SD.h>
#include <TimeLib.h>

int pinMode
int SD

void setup() {
  //---- Variables Reloj RTC ----


  // Se trata de funciones específicas para el reloj


  uint16_t TimeIsSet = 0xaa55; // Indicador para evitar la inicialización otra vez del RTC

  uint16_t startAddr = 0x0000; // Iniciar dirección donde almacenar en la NV-RAM

  uint16_t lastAddr; // Asignación nueva dirección donde almacenar en la NV-RAM



  //-- Variables de actuación --


  byte led_bomba = 22;

  byte led_bajar_ph = 25;

  byte led_subir_ph = 24;

  byte led_floragrow = 26;

  byte led_floramicro = 27;

  byte led_florabloom = 28;

  byte led_subir_temp = 30;

  byte led_bajar_temp = 29;

  byte led_bomba_aire = 23;



  Serial.begin(38400); // Activamos el Puerto seria a 38400 baud.

  Serial3.begin(38400); // Activamos el puerto serie a 38400 baud.



  pinMode(s_I, OUTPUT); // Establece el pin digital como output.

  pinMode(s_O, OUTPUT); // Establece el pin digital como output.

  pinMode(led_bomba, OUTPUT); // Establece el pin digital como output.

  pinMode(led_bajar_ph, OUTPUT); // Establece el pin digital como output.

  pinMode(led_subir_ph, OUTPUT); // Establece el pin digital como output.

  pinMode(led_floragrow, OUTPUT); // Establece el pin digital como output.

  pinMode(led_floramicro, OUTPUT); // Establece el pin digital como output.

  pinMode(led_florabloom, OUTPUT); // Establece el pin digital como output.

  pinMode(led_subir_temp, OUTPUT); // Establece el pin digital como output.

  pinMode(led_bajar_temp, OUTPUT); // Establece el pin digital como output.

  pinMode(led_bomba_aire, OUTPUT); // Establece el pin digital como output.






  if (! SD.begin(4) ) { // Iniciamos la tarjeta SD.

    Serial.println("initialization failed!"); // Mensaje de error al inicializar la SD mostrado por puerto serial (visible por monitor serial)
  }
  return;
else
{

}

Serial.println("initialization done."); // Mensaje de al inicializar la SD mostrado por puerto serial (visible por monitor serial)




RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t)); // Almacena la variable startAddr en dirección 0x08 dentro la NV- RAM.




// TimeIsSet = 0xffff  // Condición para la variable TimeIsSet para que pueda ser configurada la hora manualmente. Se desactiva una vez configurada la hora.




RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos elcomando set para poder establecer la hora.

RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos el comando get para recuperar la hora.



if (TimeIsSet ! == 0xaa55); { // Condicionamos el bucle a entrar si nuestra variable no tiene el valor del espacio de memoria en la RAM.

  RTC.stopClock()); // Paramos el contador del reloj.

  RTC.fillByYMD(2014, 9, 11); // Introducimos el año/mes/día.

  RTC.fillByHMS(13, 34, 00); // Introducimos la hora/minutos/segundos.

  RTC.setTime(); // Inicializamos el contador del reloj.

  TimeIsSet = 0xaa55; // Guardamos la configuración en su espacio de memoria.

  RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos el comando get para recuperar la hora.

  RTC.startClock();// Inicializamos el reloj.



}
else
{

}


} // put your setup code here, to run once:

}
}


void loop() {
  //---- Variables Reloj RTC ----


  // Se trata de funciones específicas para el reloj


  uint16_t TimeIsSet = 0xaa55; // Indicador para evitar la inicialización otra vez del RTC

  uint16_t startAddr = 0x0000; // Iniciar dirección donde almacenar en la NV-RAM

  uint16_t lastAddr; // Asignación nueva dirección donde almacenar en la NV-RAM



  //-- Variables de actuación --


  byte led_bomba = 22;

  byte led_bajar_ph = 25;

  byte led_subir_ph = 24;

  byte led_floragrow = 26;

  byte led_floramicro = 27;

  byte led_florabloom = 28;

  byte led_subir_temp = 30;

  byte led_bajar_temp = 29;

  byte led_bomba_aire = 23;



  Serial.begin(38400); // Activamos el Puerto seria a 38400 baud.

  Serial3.begin(38400); // Activamos el puerto serie a 38400 baud.



  pinMode(s_I, OUTPUT); // Establece el pin digital como output.

  pinMode(s_O, OUTPUT); // Establece el pin digital como output.

  pinMode(led_bomba, OUTPUT); // Establece el pin digital como output.

  pinMode(led_bajar_ph, OUTPUT); // Establece el pin digital como output.

  pinMode(led_subir_ph, OUTPUT); // Establece el pin digital como output.

  pinMode(led_floragrow, OUTPUT); // Establece el pin digital como output.

  pinMode(led_floramicro, OUTPUT); // Establece el pin digital como output.

  pinMode(led_florabloom, OUTPUT); // Establece el pin digital como output.

  pinMode(led_subir_temp, OUTPUT); // Establece el pin digital como output.

  pinMode(led_bajar_temp, OUTPUT); // Establece el pin digital como output.

  pinMode( led_bomba_aire, OUTPUT); // Establece el pin digital como output.






  if (! SD.begin(4) ) { // Iniciamos la tarjeta SD.

    Serial.println("initialization failed!"); // Mensaje de error al inicializar la SD mostrado por puerto serial (visible por monitor serial)
  }
  return;

}
else
{

}  }

uf no me deja enviar el código completo aun así, esta las lineas que me dan error debe de haber varias fallas ya que cada vez que toco algo después de consultar por aquí y por allá me salen errores diferente y en diverso numero. llevo días después de escribirlo y reescribirlo dándole vueltas agregando eliminando pero nada. este es el mensaje de error que me enviá con el menor numero de los errores.

Arduino:1.8.5 (Linux), Tarjeta:"Arduino/Genuino Mega or Mega 2560, ATmega2560 (Mega 2560)"

corregido_coregigo_8:10: error: expected initializer before 'int'
 int SD
 ^
exit status 1
expected initializer before 'int'

Este reporte podría tener más información con
"Mostrar salida detallada durante la compilación"
opción habilitada en Archivo -> Preferencias.

bueno estoy echo un lio y no se ni como remontarlo, he riañizado cambios por todos lados y no haen mas que darme mayores errores, espero que me sepan orientar por que no encuentro nada googleando que me ayude al respecto, un saludo a SurByte a Hector A y IgnoranteAbsoluto por la buena labor y empeño que realizáis aquí gracias de antemano

Sube el archivo como adjunto ya que no te deja pegarlo completo. Si superas 9k no te va a dejar.

Hola SurByte encantado. no lo hice antes por que no sabia como hacerlo para no llevarme una llamada de atención, el caso que hay te dejo también una foto para que veas que es lo que tengo entre manos, quizás los sensores los cambie por otros compatibles, por precio. y llevaría RTC DS3231 y estoy en dudas de si con el arduino mega de la foto con el Ethernet o un WEMOS Mega +WiFi R3 ATmega2560+ESP8266 que también tengo. Y con una SD conectada.? cual ¡Os parece mejor opción?

[https://www.banggood.com/Wemos-Mega-WiFi-R3-ATmega2560ESP8266-32Mb-Memory-USB-TTL-CH340G-Compatible-For-Arduino-Mega-p-1205437.html?cur_warehouse=CN[ no se como se hace eso que quieres que haga de insertar el código en adjuntos.

#include <Wire.h>
#include <DS3232RTC.h>
#include <SD.h>
#include <TimeLib.h>
int pinMode 
int SD 
void setup() {
   //---- Variables Reloj RTC
  // Se trata de funciones para el reloj
  uint16_t TimeIsSet = 0xaa55; // evitar la inicialización otra vez del RTC
  uint16_t startAddr = 0x0000; // Iniciar dirección donde almacenar en la NV-RAM
  uint16_t lastAddr; // Asignación nueva dirección donde almacenar

//-- Variables de actuación --

  byte led_bomba = 22;
  byte led_bajar_ph = 25;
  byte led_subir_ph = 24;
  byte led_floragrow = 26;
  byte led_floramicro = 27;
  byte led_florabloom = 28;
  byte led_subir_temp = 30;
  byte led_bajar_temp = 29;
  byte led_bomba_aire = 23

  Serial.begin(38400); // Activamos el Puerto seria a 38400 baud.
  Serial3.begin(38400); // Activamos el puerto serie a 38400 baud.

  pinMode(s_I, OUTPUT); // Establece el pin digital como output.
  pinMode(s_O, OUTPUT); // Establece el pin digital como output.
  pinMode(led_bomba, OUTPUT); // Establece el pin digital como output.
  pinMode(led_bajar_ph, OUTPUT); // Establece el pin digital como output.
  pinMode(led_subir_ph, OUTPUT); // Establece el pin digital como output.
  pinMode(led_floragrow, OUTPUT); // Establece el pin digital como output.
  pinMode(led_floramicro, OUTPUT); // Establece el pin digital como output.
  pinMode(led_florabloom, OUTPUT); // Establece el pin digital como output.
  pinMode(led_subir_temp, OUTPUT); // Establece el pin digital como output.
  pinMode(led_bajar_temp, OUTPUT); // Establece el pin digital como output
  pinMode( led_bomba_aire, OUTPUT); // Establece el pin digital como output.

if (! SD.begin(4) ) { // Iniciamos la tarjeta SD.
  Serial.println("initialization failed!"); // Mensaje de error al inicializar la SD mostrado por puerto serial (visible por monitor serial)
}
  return;
}
else
{

} 
 Serial.println("initialization done."); // Mensaje de al inicializar la SD mostrado por puerto serial (visible por monitor serial)
  RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t)); // Almacena la variable startAddr en dirección 0x08 dentro la NV- RAM

  // TimeIsSet = 0xffff  // Condición para la variable TimeIsSet para que pueda ser configurada la hora manualmente. Se desactiva una vez configurada la hora.

  RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos elcomando set para poder establecer la hora.
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos el comando get para recuperar la hora.
  if (TimeIsSet ! == 0xaa55);{ // Condicionamos el bucle a entrar si nuestra variable no tiene el valor del espacio de memoria en la RAM.

    RTC.stopClock()); // Paramos el contador del reloj.
    RTC.fillByYMD(2014, 9, 11); // Introducimos el año/mes/día.
    RTC.fillByHMS(13, 34, 00); // Introducimos la hora/minutos/segundos.
    RTC.setTime(); // Inicializamos el contador del reloj.
    TimeIsSet = 0xaa55; // Guardamos la configuración en su espacio de memoria.
    RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos el comando get para recuperar la hora.
    RTC.startClock();// Inicializamos el reloj.
  }
else
{

}
} // pu
}

void loop() {

   //---- Variables Reloj RTC ----
  // Se trata de funciones específicas para el reloj

uint16_t TimeIsSet = 0xaa55; // Indicador para evitar la inicialización otra vez del RTC
  uint16_t startAddr = 0x0000; // Iniciar dirección donde almacenar en la NV-RAM
  uint16_t lastAddr; // Asignación nueva dirección donde almacenar en la NV-RAM

 //-- Variables de actuación --

  byte led_bomba = 22;
  byte led_bajar_ph = 25;
  byte led_subir_ph = 24;
  byte led_floragrow = 26;
  byte led_floramicro = 27;
  byte led_florabloom = 28;
  byte led_subir_temp = 30;
  byte led_bajar_temp = 29;
  byte led_bomba_aire = 23;

  Serial.begin(38400); // Activamos el Puerto seria a 38400 baud.
  Serial3.begin(38400); // Activamos el puerto serie a 38400 baud.

  pinMode(s_I, OUTPUT); // Establece el pin digital como output.
  pinMode(s_O, OUTPUT); // Establece el pin digital como output.
  pinMode(led_bomba, OUTPUT); // Establece el pin digital como output.
  pinMode(led_bajar_ph, OUTPUT); // Establece el pin digital como output.
  pinMode(led_subir_ph, OUTPUT); // Establece el pin digital como output.
  pinMode(led_floragrow, OUTPUT); // Establece el pin digital como output.
  pinMode(led_floramicro, OUTPUT); // Establece el pin digital como output.
  pinMode(led_florabloom, OUTPUT); // Establece el pin digital como output.
  pinMode(led_subir_temp, OUTPUT); // Establece el pin digital como output.
  pinMode(led_bajar_temp, OUTPUT); // Establece el pin digital como output.
  pinMode( led_bomba_aire, OUTPUT); // Establece el pin digital como output.

if (! SD.begin(4) ) { // Iniciamos la tarjeta SD.

  Serial.println("initialization failed!"); // Mensaje de error al inicializar la SD mostrado por puerto serial (visible por monitor serial)
}
  return;

}
else
{

} 

  Serial.println("initialization done."); // Mensaje de al inicializar la

}

no me caben ay val los primeros 5000 caracteres

Captura de pantalla de 2019-02-04 00-39-15.png

](https://www.banggood.com/Wemos-Mega-WiFi-R3-ATmega2560ESP8266-32Mb-Memory-USB-TTL-CH340G-Compatible-For-Arduino-Mega-p-1205437.html?cur_warehouse=CN)

los siguientes 500o caracteres

SD mostrado por puerto serial (visible por monitor serial)
  RTC.setRAM(0, (uint8_t *)&startAddr, sizeof(uint16_t)); // Almacena la variable startAddr en dirección 0x08 dentro la NV- RAM.

  // TimeIsSet = 0xffff  // Condición para la variable TimeIsSet para que pueda ser configurada la hora manualmente. Se desactiva una vez configurada la hora.

  RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos elcomando set para poder establecer la hora.
  RTC.getRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos el comando get para recuperar la hora.

  if (TimeIsSet ! == 0xaa55); { // Condicionamos el bucle a entrar si nuestra variable no tiene el valor del espacio de memoria en la RAM.

    RTC.stopClock()); // Paramos el contador del reloj.
    RTC.fillByYMD(2014, 9, 11); // Introducimos el año/mes/día
    RTC.fillByHMS(13, 34, 00); // Introducimos la hora/minutos/segundos.
    RTC.setTime(); // Inicializamos el contador del reloj.
    TimeIsSet = 0xaa55; // Guardamos la configuración en su espacio de memoria.
    RTC.setRAM(54, (uint8_t *)&TimeIsSet, sizeof(uint16_t)); // Usamos el comando get para recuperar la hora.
    RTC.startClock();// Inicializamos el reloj.
  }
else
{
}
 // En caso de que ya tenga la hora establecida:
 RTC.getTime(); // Pedimos la hora al reloj.

} // Cerramos el bucle.

  RTC.ctrl = 0x00; // 0x00=desactiva SQW pin, permite la activación de un reloj externo al programa, por lo que frecuencias podemos del 0x11=4096Hz, establecer reloj. varia 0x10=1Hz, 0x12=8192Hz, 0x13=32768Hz

RTC.setCTRL(); // Establecemos la frecuencia escogida.

 } 
 void loop ()

  //--- Variables SD
  File myFile;

  // Variables Multiplexor

  int channel_tx(int channel, char* data); // Esto es una variable que nos permitirá abrir el canal correcto y enviar a través del TX la información que le enviemos.

  byte s_I = 35; // Switch I conectado al pin 35.
  byte s_O = 34; // Switch O conectado al pin 34.
  int canal = 99; // Tenemos 4 posibles canales RX y TX en el Mux/Demux(0-3). Iniciamos el canal 99 paracque de esta forma no abramos un canal de forma inadvertida.
  char cadena[24]; // Declaramos una variable para almacenarlo que tenemos en cola en el puerto serial, que después asignaremos a otras variable en función de la combinación del Mux/Demux(0-3).
  byte contador = 0; // Variable contador para la asignación de valores del Puerto mediante función Case

  /*Serial entrantes */
  int control_sensores[4] = {1, 1, 1, 1}; // Matriz que nos permite activar o desactivar la lectura de los sensores, 1 activado, 0 desactivado.
  int tipos_sensores[4] = {1, 2, 3, 4}; //DO==>1,ORP==>2,PH==>3,EC==>4 Orden de guardado de los valores de los sensores en la matriz

  //---- Variables de conversión de Sensores
  String valor_do = ""; // Variable donde se almacena respuesta del sensorde DO.
  String valor_orp = ""; // Variable donde se almacena respuesta del sensor de ORP.
  String valor_ph = ""; // Variable donde se almacena respuesta del sensor de pH.
  char valor_orp_temp[8]; // Vector de char que usaremos en la subrutina de convertir un String a un float para poder operar.Tiene 8 caracteres ya que la respuesta se puede presentar como XXXXX.XX
  float valor_orp_0 = 0; // Variable donde guardamos el valor numérico del sensor ORP.
  char valor_do_temp[5]; // Vector de char que usaremos en la subrutina de convertir un String a un float para poder operar. Tiene 5 caracteres ya que la respuesta se puede presentar como XXX.XX
float valor_do_0 = 0; // Variable donde guardamos el valor numérico del sensor DO.
  char valor_ph_temp[4]; // Vector de char que usaremos en la subrutina de convertir un String a un float para poder operar. Tiene 4 caracteres ya que la respuesta se puede presentar como X.XX
  float valor_ph_0 = 0; // Variable donde guardamos el valor numérico del sensor DO.
  String valor_ec = ",,,"; // Variable donde se almacena respuesta del sensor de DO. La inicializamos si estar vacía, ya que al tener más de un valor en su respuesta, si queremos extraer los valores separados por comas, debemos inicializarla de igual modo.
  String valor_ec_0_temp = ""; // String donde guardaremos la extracción de la variable ec correspondiente a la EC para luego proceder a convertirla en float.
  String valor_ec_1_temp = ""; // String donde guardaremos la extracción de lavariable ec correspondiente a la TDS para luego proceder a convertirla en float.
  String valor_ec_2_temp = ""; // String donde guardaremos la extracción de la variable ec correspondiente a la SAL para luegoproceder a convertirla en float.
  String valor_ec_3_temp = ""; // String donde guardaremos la extracción de la variable ec correspondiente a la SG para luego proceder a convertirla en float.
  char valor_ec_0_temp2[7]; // Vector de char que usaremos en la subrutina de convertir un String a un float para poder operar. Tiene 7 caracteres ya que la respuesta se puede presentar como XXXX.XX
  char valor_ec_1_temp2[7]; // Vector de char que usaremos

el tercer trozo de 5000 caracteres

en la subrutina de convertir un String a un float para poder operar. Tiene 7 caracteres ya que la respuesta se puede presentar como XXXX.XX
  char valor_ec_2_temp2[7]; // Vector de char que usaremos en la subrutina de convertir un String a un float para poder operar. Tiene 7 caracteres ya que la respuesta se puede presentar como XXXX.XX
  char valor_ec_3_temp2[7]; // Vector de char que usaremos en la subrutina de convertir un String a un float para poder operar. Tiene 7 caracteres ya que la respuesta se puede presentar como XXXX.XX
  float valor_ec_0 = 0; // Variable donde guardamos el valor numérico del sensor EC.
  float valor_ec_1 = 0; // Variable donde guardamos el valor numérico del sensor TDS.
  float valor_ec_2 = 0; // Variable donde guardamos el valor numérico del sensor SAL.
  float valor_ec_3 = 0; // Variable donde guardamos el valor numérico del sensor SG.
  float valor_temp = 0; // Variable donde guardamos el valor numérico del sensor de temperatura.

  //-- Variables de condición –

 boolean bomba = false;
  boolean bajar_ph = false;
  boolean subir_ph = false;
  boolean floragrow = false;
  boolean floramicro = false;
  boolean florabloom = false;
  boolean subir_temp = false;
  boolean bajar_temp = false;
  boolean bomba_aire = false;

RTC.getTime(); // Obtenemos la hora del reloj
if (RTC.minute <= 15) { // Queremos encender la bomba durante 15 minutos, por lo que la encenderemos durante el primer cuarto de hora de cada hora, esto se consigue con la condición que los minutos sean menores o iguales a 15.
  bomba = true; // Activamos el condicional que nos permitirá iniciar las diferentes rutinas asociadas a la adquisición de datos y respuesta de los actuadores.

    digitalWrite(led_bomba, HIGH); // Activamos el pin de la bomba que nos permitirá a excitar el relé para cerrar el circuito.
}
else
{

}
 // Si no cumplimos con el requisito:
bomba = false; // No activamos las diferentes subrutinas.
  digitalWrite(led_bomba, LOW); // No activamos la excitación del relé.

  /*Subrutina de temperatura*/
  valor_temp = read_temp();// Igualamos nuestra variable a la variable de la subrutina.
  millis (50000);// Hacemos un delay para que el tiempo total de lecturas será cada 10 segundos.

  /*Subrutina de lectura de datos de sensores y adquisición datos por pantalla y SD.
    Lectura y asociación de datos a las variables Como se ha comentado anteriormente, todo el programa se basa en el
    encendido o apagado de la bomba de agua. Consecuentemente hemos de
    vincular la lectura y adquisición de datos a ello.*/

  if (bomba) { //Condición de que la bomba haya sido encendida.

    for (int i = 0; i <= 3; i++) { // Hemos de leer todos los canales del MUX/DEMUX ya que en cada canal tenemos conectado un sensor. Canales 0-3

      if (control_sensores[i] == 1) { // En función de los canales que habilitemos leeremos los sensores asociados a cada canal
        canal = i; // iniciamos el canal en función del contador
        channel_tx(canal, "R"); // Enviamos el commando de lectura, parámetro especificado por el fabricante
        switch (tipos_sensores[i]) { // Asimismo necesitamus un tiempo de lectura mínimo facilitado por el fabricante de los sensores, para proceder a una buena recepción de los datos.
         case 1:
            millis (70000); // Delay requerido de 700ms para el sensor de DO.
            break;
          case 2:
            millis (150000); // Delay requerido de 1500ms para el sensor de ORP.
            break;
          case 3:
            millis (80000); // Delay requerido de 500ms para el sensor de pH.
            break;
          case 4:
            millis (150000); // Delay requerido de 1500ms para el sensor de EC.
            break;
        }

        /*Iniciamos la lectura de los sensores por los diferentes canales*/

        if (Serial3.available () ) { // Cuando tengamos cola en la entrada del puerto serial, buffer,
         memset (cadena, 0, sizeof (cadena) ); // Primero variable limpiamos de la registros anteriores
          while (Serial3.available () > 0) { // Mientras tengamos un valor en el buffer
            delay (5); // Esperamos 5ms para evitar rotura del mensaje, ya que si lo leemos directamente puede generarnos errores en forma de ruido.
            cadena[contador] = Serial3.read(); // Asignamos la lectura del buffer en la variable cadena en la posición contador.
            contador++; // Sumamos +1 al contador para cambiar de posición en la variable cadena.

          }

          switch (tipos_sensores[i]) { // Asignamos cada posición de la variable cadena a la variable
           case 1: // El valor 1 de la variable tipos_sensores () pertenece al sensor de DO.
              valor_do = cadena; // Asignación del espacio de memoria 0 de la cadena a la variable del sensor DO.
              break; // Cerramos el case 1.
            case 2: // El valor 2 de la variable tipos_sensores () pertenece al sensor de ORP.
              valor_orp = cadena; // Asignación del es

el cuarto archivo de 5000 caracteres

pacio de memoria 1 de la cadena a la variable del sensor ORP.
             break; // Cerramos el case 2.
           case 3: // El valor 3 de la variable tipos_sensores () pertenece al sensor de pH.
             valor_ph = cadena; // Asignación del espacio de memoria 2 de la cadena a la variable del sensor pH.
             break; // Cerramos el case 3.
           case 4: // El valor 4 de la variable tipos_sensores () pertenece al sensor de EC.
             valor_ec = cadena; // Asignación del espacio de memoria 3 de la cadena a la variable del sensor EC.
             millis (500000);
             break; // Cerramos el case 3.
         }
contador = 0; // Reiniciamos el contador.
       }
     }

     /*Conversión a variables operacionales.
       Hemos de convertir las variables de tal forma que cuando hagamos volcado,
       podamos operar con los registros.*/

     //---------------- PH
     valor_ph.toCharArray(valor_ph_temp, 4); // Convertimos de un String a un Array de 4 Char.
     valor_ph_0 = atof(valor_ph_temp); // Convertimos el array en un float consiguiendo que podamos operar con él.

     //---------------- DO 
     valor_do.toCharArray(valor_do_temp, 5); // Convertimos de un String a un Array de 5 Char, ya que según el datasheet del fabricante el sensor nos retorna una respuesta en formato XX.XX.
     valor_do_0 = atof(valor_do_temp); // Convertimos el array en un float consiguiendo que podamos operar con él.

  //-------------- ORP 
     valor_orp.toCharArray(valor_orp_temp, 8); // Convertimos de un String a un Array de 8 Char, ya que según el datasheet del fabricante el sensor nos retorna una respuesta en formato XXXXX.XX.

     valor_orp_0 = atof(valor_orp_temp); // Convertimos el array en un float consiguiendo que podamos operar con él.

     //------- EC + TDS + SAL + SG 

// ---- valor de EC 

     int i = 0; // Declaramos contador.
     boolean vaa = true; // Declaramos variable que nos permite entrar y salir del bucle contador de la posición de la coma.
     int posicion = 0; // Asignamos como posición inicial la posición 0.
     while (vaa) { //Subrutina de contador de posiciones dentro del String hasta la coma.
       i++; // Sumaremos posiciones hasta que,
       if (valor_ec[i] == ',') { // La posición en la que nos encontremos dentro del String sea una coma.
         posicion = i; // Asignaremos la posición de la coma a la variable posición
         vaa = false; // Cancelamos el bucle
       }
     }

     valor_ec_0_temp = valor_ec.substring(4, posicion); // Asignamos de la variable que conocemos vaya de la posición 4 hasta la posición de la coma.
     valor_ec_0_temp.toCharArray(valor_ec_0_temp2, 7); // Convertimos de un String a un Array de 7 Char, ya que el sensor lee hasta 7 posiciones.
     valor_ec_0 = atof(valor_ec_0_temp2); // Convertimos de Array to Float

     // ----- valor de TDS

vaa = true;
     int posicion_1 = 0;
     i = posicion + 1;
     while (vaa) {
       i++;
       if (valor_ec[i] == ',' ) {
         posicion_1 = i;
         vaa = false;
       }
}

     valor_ec_1_temp = valor_ec.substring(posicion + 1, posicion_1); // Usamos la posición anterior + 1 porque en la variable tiene asignada la posición de la coma, no la del primer valor después de la coma.
    valor_ec_1_temp.toCharArray (valor_ec_1_temp2, 7);
     valor_ec_1 = atof (valor_ec_1_temp2);

  // --- valor de SALinity

     vaa = true;
     int posicion_2 = 0;
     i = posicion_1 + 1;
     while (vaa) {
       i++;
       if (valor_ec[i] == ',' ) {
         posicion_2 = i;
         vaa = false;
       }
}

     valor_ec_2_temp = valor_ec.substring(posicion_1 + 1, posicion_2);
     valor_ec_2_temp.toCharArray(valor_ec_2_temp2, 7);
     valor_ec_2 = atof(valor_ec_2_temp2);

     // ----- valor de SG

     valor_ec_3_temp = valor_ec.substring (posicion_2 + 1, posicion_2 + 4); // Usamos la posición anterior + 1 porque en variable tiene
   
    valor_ec_3_temp.toCharArray(valor_ec_3_temp2, 5);
    valor_ec_3 = atof(valor_ec_3_temp2);

if (RTC.hour < 10) { // El reloj usado no muestra los horas/minutos/segundos menores a
       // 10 con el 0 delante, cosa que no cumpliria con la visualización estándar
       // de la hora en HH/MM/SS. Por ello hacemos una condición a cual no añada un 0
       // en caso de que el valor retornado sea inferior a 10.

       Serial.print ("0");  // Añadimos el 0, pero sólo por pantalla.
       Serial.print (RTC.hour, DEC); // Seguidamente añadimos la hora.

     } else { // En caso de que el valor horario sea superior a 10, imprimimos directamente el valor.
       Serial.print (RTC.hour, DEC);

     }

     Serial.print ( ":" ); // Añadimos “:” para mostrar según estándares.
     if (RTC.minute < 10 { // Repetimos el mismo proceso utilizado en la hora, esta vez para los minutos.
     Serial.print ( "0" );
       Serial.print (RTC.minute, DEC);
     } else {
      Serial.print (RTC.minute, DEC)

ya que dan menos no tengo idea de como hacerlo mejor ni si quiera se si esta manteniendo el formato

Serial.print (RTC.minute, DEC);
     }

     Serial.print ( ":" );

     if (RTC.second < 10) { // Volvemos a repetir el mismo proceso utilizado en los minutos, esta vez para los segundos.
     Serial.print ( "0" );
       Serial.print (RTC.second, DEC);
     } else {
       Serial.print (RTC.second, DEC);
     }
     Serial.print ( " " ); // Introducimos una separación entre la hora y la fecha

     if (RTC.day < 10) {  // Como en el caso de la hora, pasa el mismo suceso con la fecha, en caso de que el valor devuelto de día sea inferior a 10 se le tiene que añadir manualmente, incluido también el mes.
     Serial.print ( "0" );
       Serial.print (RTC.day, DEC);
     }
else
{

}
Serial.print (RTC.day, DEC);

     }
     Serial.print ( "-" );
     if (RTC.month < 10) {
     Serial.print ( "0" );
       Serial.print (RTC.month, DEC);
     } else {
       Serial.print (RTC.month, DEC);
     }
     Serial.print ( "-" );

     Serial.println (RTC.year, DEC); // En caso del año nos devuelve un numeral de cuatro dígitos por lo que no es necesario añadirle un 0. En caso del año añadimos un println para incluir salto de línea.

    //---------------- PH

Serial.print ( "PH: " );

     if (control_sensores[2] == 1) { // Hacemos un bucle por el cual nos mostrará el valor numérico del sensor (utilizamos la variable en formato Float),

     //siempre que este asignada la variable control_sensores y posición 2 como1 en la posición correspondiente al sensor de pH.

     Serial.println (valor_ph_0); // Valor en Float de la medición del sensor.
     } else {
 Serial.println ( "No medido" ); // Mostraremos por pantalla la siguiente información.
     }

    //- EC + TDS + SAL + SG 

 Serial.print ( "EC: " ); // Imprimimos por pantalla el valor de EC.

     if (control_sensores[3] == 1) { // Hacemos un bucle por el cual nos mostrará el valor numérico del sensor (utilizamos la variable en formato Float),
     //siempre que este asignada la variable control_sensores y posición 3 como 1 en la posición correspondiente al sensor de pH.

     Serial.println (valor_ec_0);
     } else {
       Serial.println ( "No medido" );
     }
     Serial.print ( "TDS: " ); // Imprimimos por pantalla el valor de TDS.
     if (control_sensores[3] == 1) {
     Serial.println (valor_ec_1);
     } else {
       Serial.println ( "No medido" );
     }
     Serial.print ( "SAL: " ); // Imprimimos por pantalla el valor de SAL.
     if (control_sensores[3] == 1) {
     Serial.println (valor_ec_2);
     } else {
       Serial.println ( "No medido" );
     }
     Serial.print ( "SG: " ); // Imprimimos por pantalla el valor de SG.
     if (control_sensores[3] == 1) {
     Serial.println (valor_ec_3);
     } else {
       Serial.println ( "No medido" );
     }

   //------ ORP 

Serial.print ( "ORP: " );

     if (control_sensores[1] == 1) { // Hacemos un bucle por el cual nos mostrará el valor numérico del sensor (utilizamos la variable en formato Float),
     // siempre que este asignada la variable control_sensores y posición 3 como1 en la posición correspondiente al sensor de pH.
     Serial.println (valor_orp_0);
     } else {
       Serial.println ( "No medido" );
     }
    Serial.print ( "DO: " );

       //---------------- DO

if (control_sensores[0] == 1) {
     Serial.println (valor_do_0);
     } else {
       Serial.println ( "No medido" );
     }
     Serial.print ( "TEMP: " );
     Serial.println (valor_temp);
     myFile = SD.open ("test.csv", FILE_WRITE); // Abrimos el fichero “test.csv”, en caso de que en la SD no hubiese ningún fichero con ese nombre y formato,
              // automáticamente se crea uno con el nombre especificado y el formato.

     if (myFile) { // No grabaremos nada si la variable myFile no ha sido declarado como escritura.

     // Todos los envíos de datos a la SD se harán con el comando print(), ya que debemos crear una única fila dentro del archivo .csv

     if (RTC.hour < 10) {
         myFile.print ( "0" );
         myFile.print (RTC.hour, DEC);
       } else {
         myFile.print (RTC.hour, DEC);
       }
       myFile.print ( ":" );
       if (RTC.minute < 10) {
         myFile.print ( "0" );
         myFile.print (RTC.minute, DEC);
       } else {
         myFile.print (RTC.minute, DEC);

       }
       myFile.print ( ":" );
       if (RTC.second < 10) {
         myFile.print ( "0" );
         myFile.print (RTC.second, DEC);
       } else {
         myFile.print (RTC.second, DEC);
       }

       myFile.print ( "," );
       if (RTC.day < 10) {
         myFile.print ( "0" );
         myFile.print (RTC.day, DEC);
       } else {
         myFile.print (RTC.day, DEC);
       }
       myFile.print ( "-" );
       if (RTC.month < 10) {
         myFile.print ( "0" );
         myFile.print (RTC.month, DEC);
       } else {
         myFile.print (RTC.month, DEC);

       }
       myFile.print ( "-" )

esto es demencial debe de haber una forma de poder colocar un codigo con la capacidad total de nuestros arduinos sobre todo megas y superiores

int (RTC.hour, DEC);
      }
      myFile.print ( ":" );
      if (RTC.minute < 10) {
        myFile.print ( "0" );
        myFile.print (RTC.minute, DEC);
      } else {
        myFile.print (RTC.minute, DEC);
      }
       myFile.print ( ":" );
      if (RTC.second < 10) {
        myFile.print ( "0" );
        myFile.print (RTC.second, DEC);
      } else {
        myFile.print (RTC.second, DEC);
      }
      myFile.print ( " " );
      if (RTC.day < 10 {
      myFile.print ( "0" );
        myFile.print (RTC.day, DEC);
      } else {
        myFile.print (RTC.day, DEC);
      }
      myFile.print ( "-" );
      if (RTC.month < 10) {
      myFile.print ( "0" );
        myFile.print (RTC.month, DEC);
      } else {
        myFile.print (RTC.month, DEC);
      }

      myFile.print ( "-" );
      myFile.println (RTC.year, DEC);

      /* Las condiciones que establecemos, se han declarado en la subrutina de los actuadores,  en función de las condiciones
        que lean los sensores, quedará en el fichero de registro.*/

      if (led_bomba) {
      myFile.println ("Bomba de agua ON");
      } else {
       myFile.println ("Bomba de agua OFF");

      }

      if (subir_ph && !bajar_ph) {
      myFile.println ("Subir Ph ON");
        myFile.println ("Bajar Ph OFF");
      } else if (!subir_ph && bajar_ph) {
      myFile.println ("Subir Ph OFF");
        myFile.println ("Bajar Ph ON");
      } else {
        myFile.println ("Subir Ph OFF");
        myFile.println ("Bajar Ph OFF");
      }

      if (floragrow && floramicro && florabloom) {
      myFile.println ("Agregar FloraGrow ON");
        myFile.println ("Agregar FloraMicro ON");
        myFile.println("Agregar FloraBloom ON");
      } else {
        myFile.println ("Agregar FloraGrow OFF");
        myFile.println ("Agregar FloraMicro OFF");
        myFile.println ("Agregar FloraBloom OFF");

      }

      if (subir_temp && !bajar_temp) {
      myFile.println ("Subir Temperatura Deposito ON");
        myFile.println ("Bajar Temperatura Deposito OFF");
      } else if (!subir_temp && bajar_temp) {
      myFile.println ("Subir Temperatura Deposito OFF");
        myFile.println ("Bajar Temperatura Deposito ON");
      } else {
        myFile.println ("Subir Temperatura Deposito OFF");
        myFile.println ("Bajar Temperatura Deposito OFF");
      }

     if (bomba_aire) {
      myFile.println ("Bomba de aire ON");
      } else {
        myFile.println ("Bomba de aire OFF");
      }
      myFile.println ( "" );

    }

    myFile.close();

    /*Subrutina tiempos de lectura de los sensores*/

    for ( int i = 0; i <= 3; i++ ) 
      if (control_sensores [i] == 0 ) {
        switch ( tipos_sensores [i] ) {
          case 1:
            millis (70000);
            break;
          case 2:
            millis (150000);
            break;
          case 3:
            millis (80000);
            break;
          case 4:
          millis (150000);
            break;

        }

/* Subrutina MUX/DEMUX */

        int channel_tx (int channel, char* data) { // Esta función abrirá el canal del multiplexor 

          switch (channel) {// Función que nos permitirá “saltar” de canal a canal (0-3)
              .
            case 0:// Abriremos el canal Y0 que corresponde con el sensor de DO.

              digitalWrite (s_I, LOW); // Y0 abierto con SI=0.
              digitalWrite (s_O, LOW); //Y0 abierto con SO=0.
              Serial3.print ( '\r' ); // Primero enviamos un <CR> para eliminar cualquier basura que haya quedado en el búfer RX 
              Serial3.print (data); // Todos los datos que van a un dispositivo Atlas Scientific si se transmiten con un <CR>.
              break;// Salimos del case 1.
            case 1: // Abriremos el canal Y1 que corresponde con el sensor de ORP.
              digitalWrite (s_I, HIGH); // Y1 se abre con SI=1.
              digitalWrite (s_O, LOW); //Y1 se abre con SO=0.
              Serial3.print ( '\r' ); // Enviamos un <CR> (en blanco) primero para limpiar cualquier ruido/data.
              // El ruido se puede producir cuando cambiamos entre canales.
              Serial3.print (data); // Enviamos el comando.
              Serial3.print ( '\r' ); // Para que el comando llegue es condición que enviemos un <CR>, así lo exige el fabricante.
              break;
            case 2:
              digitalWrite(s_I, LOW);
              digitalWrite (s_O, HIGH);
              Serial3.print ( '\r' );
              Serial3.print (data);
              Serial3.print ( '\r' );
              break;
            case 3:
              digitalWrite (s_I, HIGH);
              digitalWrite (s_O, HIGH);
              Serial3.print ( '\r' );
              Serial3.print ( data );
              Serial3.print ( '\r' );
             break;
          }

          /*
            Void de Temperatura.Void para la lectura y procesado de la señal que nos transmite el sensor de temperatura.*/

          float read_temp (void) { // Función de lectura

este es el final si me pudierais ayudar a enviar el código en una pieza os lo agradecería he estado quitando todos los comentarios que me parecían mas superficiales para reducir los caracteres pero no he podido hacer mas espero no haber hecho mucho destrozo gracias

de temperatura.
            float v_out; // Voltaje de salida del sensor de temperatura.
            float temp; // Variable para el valor final de temperatura.
            v_out = analogRead (A7); // Lectura del pin A7 dónde hemos conectado el sensor.
            v_out *= .00488; // Convertimos el valor de tensión en ADC a Volts (utilizamos 0,0048 porque el sensor esta alimentado a 5V
            v_out *= 1000; // Convertimos de V a mV.
            temp = 0.0306 * v_out - 20.5128; // Aplicamos la función característica del sensor y convertimos de V a ºC
            return temp; // Devolvemos el valor de temperatura.

          }

Espero que podamos resolver esto que me parece a mi que es de bastante interés entre los DYD 
gracias Amigos.
}

Si un código supera los 9k entonces lo adjuntas, no lo pones en 5 post como has hecho y ademas se usa la etiqueta de código como dicen las normas. Acabo de editar todos y cada uno de tus post.

Lee las normas por favor!!

Gracias SurByte Campeón he leído las normas y no entiendo en que icono debo de pulsar para hacer como lo dices, disculpa mi ignorancia supina

disculpa fui un idiota gracias por la ayuda queda ahora estupendo

bueno espero que esta sea la buena ya herré bastante y estoy ya sin batería ni conexión cosas del Siglo XXI

Sketch.ino (32.6 KB)

Bueno, un código no se sube como pdf, asi que me tomé la tarea de bajarlo y ponerle un nombre Sketch.ino (la extensión de Arduino).

Ahora si podrán descargarlo y leerlo.

Sin que lo tomes a mal, tu código esta muy muy mal.

Tiene muchas repeticiones, y lo peor es que la copia del pdf a .ino que hice arrastró mas errores porque ha tomado algunos cambios de linea que antes no estaban.

No se que quieres hacer asi comenzamos de nuevo y vamos paso a paso.

hola SurByte De acuerdo empecemos de nuevo te envío el codigo como me pediste. mire lo que me dijistes de alguna cosa repetida y demás, también intente corregir alguna cosa. ahora me da mas errores en la pantalla de sucesos. pero son muy repetidos y debe ser algo que se me pasa, ya no se ni por donde seguir a ver si, conseguimos dar con la tecla.

No me cabe tampoco el mensaje de errores. los errores están repetidos. debe ser de novatos, o que ya me viene haciendo falta un ajustes de lentes

codigo_de_nutriente_de_riego_ultima_correcion_2.ino (32.9 KB)

codigo_de_nutriente_de_riego_ultima_correcion_2.ino (32.9 KB)

codigo_de_nutriente_de_riego_ultima_correcion_2.ino (32.9 KB)

errores.ino (23.5 KB)