Tiempo de espera en una interrupcion.

Saludes a todos. En esta ocasión me gustaría saber si existe una manera de dar un tiempo de espera a una interrupción. Os explico. Estoy usando un sensor de flujo común conectado a arduino mega, pretendo tomar la cantidad de fluido leído y luego enviar esa info mediante un SIM900 a una pagina web para verla en la nube.

El problema es que no he podido hacer que me lea por un tiempo la cantidad de fluido y luego tomar esa cantidad y enviarla. He probado por aparte el sensor de flujo (solo de leer el la cantidad de fluido) y funciona sin problemas, pero a la hora de querer tomar el valor y enviarlo siempre me da como valor leído 0.

Aclaro que el envío de la info no es el problema sino la lectura antes de ser enviada.

Os anexo el código que estoy usando.

#include <SoftwareSerial.h>
SoftwareSerial SIM900(10, 11);

// -----------------SIM900--------------
int respuesta;
char aux_str[50];
//------------------------------------------------------------------

//Pines de Entrada Sensor de Flujo
//----------------------------------------------
byte statusLed    = 13;
float litros=0;
byte sensorInterrupt = 0;
byte sensorPin       = 2;
float calibrationFactor = 7.150;
volatile byte pulseCount;  
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;
//----------------------------------------------

//--------------------- Setup General --------------------------//
void setup()
{
  Serial.begin(19200);     



//************* Sensor de Flujo ********//
  pinMode(statusLed, OUTPUT);
  digitalWrite(statusLed, HIGH);
  pinMode(sensorPin, INPUT);
  digitalWrite(sensorPin, HIGH);
  pulseCount        = 0;
  flowRate          = 0.0;
  flowMilliLitres   = 0;
  totalMilliLitres  = 0;
  oldTime           = 0;
  attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
//***********************************

//************* SIM900 ********//
  SIM900.begin(19200);          
  delay(1000);
  Serial.println("Iniciando...");
  Iniciar();                    
}
//------------------------------------------------------------------//

void loop()
{
}

//************* Inicio de la conexion GPRS ********//
void Iniciar()
{
  enviarAT("AT+CPIN?", "OK", 6000);                       //------------------------------------------------------------ Determinando el PIN del SIM CARD.
  Serial.println("Conectando a la red...");
  delay (5000);
  enviarAT("AT+CSQ", "OK", 3000);                         //------------------------------------------------------------ Midiendo la calidad de la senal, 15 a mas, es muy buena.
  while ( enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 0 ) //------------------------------------------------------------ Espera hasta estar conectado a la red movil
  {
  //DataLogger();                                           //------------------------------------------------------------ Si no se encuetra la red, se activa la funcion de Datalogguer
  }
  Serial.println("Conectado a la red.");
  enviarAT("AT+CGATT?", "OK", 2000);                      //------------------------------------------------------------ Iniciamos la conexión GPRS
  enviarAT("AT+CGATT=1\r", "OK", 2000);                   //------------------------------------------------------------ Activamos la conexión GPRS
  enviarAT("AT+CGCLASS?", "OK", 3000);                   //------------------------------------------------------------ Configurarmos el SIM900 de acuerdo a la clase de GPRS a usar.
  enviarAT("AT+CSTT=\"web.emovil\",\"webemovil\",\"webemovil\"", "OK", 3000);           //------------------------------ Configuramos la APN a usar para la comunicacion
  enviarAT("AT+CSTT=\"CMNET\"", "OK", 3000);              ////----------------------------------------------------------- Activamos la APN
  enviarAT("AT+CIICR", "OK", 3000);                       //------------------------------------------------------------//Activamos la conexion inalambrica
  enviarAT("AT+CIFSR", "", 4000);                         //------------------------------------------------------------//Se obtiene la direccion IP local
  Sensor1();
}
//*********************************************//

//////////////////////////////////////////////////////////////////////////////
void Sensor1()
{
  if((millis() - oldTime) > 1000) 
  { 
    detachInterrupt(sensorInterrupt);
    flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
    oldTime = millis();
    flowMilliLitres = (flowRate / 60) * 1000;
    totalMilliLitres += flowMilliLitres;
    unsigned int frac;
    frac = (flowRate - int(flowRate)) * 10;
    pulseCount = 0;
    attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
    Serial.print(totalMilliLitres); 
    Serial.println("mL");
   }

 float Flujo=totalMilliLitres;
  char str[6];
  char direccion[50];
  dtostrf(Flujo, 6, 1, str);
  sprintf(direccion, "GET /update?api_key=HOWMBIHA1WN5NI2S&field1=%s HTTP/1.1\r\nHost: api.thingspeak.com\r\nConnection: close\r\n\r\n", str);
  
  if (enviarAT("AT+CREG?", "+CREG: 0,1", 6000) == 1)  
  { //Comprueba la conexion a la red 
      enviarAT("AT+CIPSTART=\"TCP\",\"184.106.153.149\",\"80\"", "CONNECT OK", 5000); //Inicia una conexión TCP
      // Envíamos datos a través del TCP

      sprintf(aux_str, "AT+CIPSEND=%d", strlen(direccion));
      if (enviarAT(aux_str, ">", 10000) == 1) {
          enviarAT(direccion, "OK", 5000);
          enviarAT("AT+CIPCLOSE", "OK", 3000);
          enviarAT("AT+CIPSHUT\r", "OK", 3000);
          Serial.println("Envio de Datos satisfactorio");
          delay(4000);
      }
      
  }
  else  
  {
      Serial.println("Error en el envio");
  }
} 
//*********************************************//


void pulseCounter()
{
  pulseCount++;
}

Os agradezco una vez mas por vuestra atencion y gracias de antemano.
Saludes.
att: N.A.V

Buenas, así ha simple vista me parece que es que no "esperas a nadie" en tu sketch, es decir, entras configuras en en setup y despues inicias la conexion, si ha pasado mas de un segundo calculas el caudal y despues lo envias a thingspeak y terminas el programa, no hay ningún bucle ni delay que espere hasta que el contador se vaya incrementando.

Creo que deberías meter el codigo de la funcion Sensor1 en el loop, despues antes de calcular el caudal imprimes el valor de pulseCount y así puedes comprobar si se ha incrementado acorde al flujo.

Saludos,

Venga Vale Alfredomrh, dejadme hago tu propuesta...!!!!! Agradezco vuestra opinión..!!!

Disculpad el embrollo y quizás la ignorancia alfredomrh, Hice lo que me habíais recomendado, ademas he colocado el if en el loop con un while y ahora se me queda leyendo como bucle infinito no me manda a la función Sensor1 para enviarla.

El problema esta en que quiero que una vez iniciado el programa me espere cierta cantidad de tiempo, digamos unos 10 sgds de lectura de la variable (de mi interés es totalMilliLitres) y luego ya tome esa lectura y la envíe, cuando se vuelva a realizar la función que lea siempre la variable “totalMilliLitres” y me la envíe, si cambio perfecto y si no hubo cambio, igual perfecto.

Os dejo lo que edite en el codigo.

#include <SoftwareSerial.h>
SoftwareSerial SIM900(10, 11);

// -----------------SIM900--------------
int respuesta;
char aux_str[50];
//------------------------------------------------------------------

//Pines de Entrada Sensor de Flujo
//----------------------------------------------
byte statusLed    = 13;
float litros=0;
byte sensorInterrupt = 0;
byte sensorPin       = 2;
float calibrationFactor = 7.150;
volatile byte pulseCount;  
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;
//----------------------------------------------

//--------------------- Setup General --------------------------//
void setup()
{
  Serial.begin(19200);     



//************* Sensor de Flujo ********//
  pinMode(statusLed, OUTPUT);
  digitalWrite(statusLed, HIGH);
  pinMode(sensorPin, INPUT);
  digitalWrite(sensorPin, HIGH);
  pulseCount        = 0;
  flowRate          = 0.0;
  flowMilliLitres   = 0;
  totalMilliLitres  = 0;
  oldTime           = 0;
  attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
//***********************************

//************* SIM900 ********//
  SIM900.begin(19200);          
  delay(1000);
  Serial.println("Iniciando...");                   
}
//------------------------------------------------------------------//

void loop()
{
  while(totalMilliLitres == 0)
  {
    if((millis() - oldTime) > 1000) 
      { 
    detachInterrupt(sensorInterrupt);
    flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
    oldTime = millis();
    flowMilliLitres = (flowRate / 60) * 1000;
    totalMilliLitres += flowMilliLitres;
    unsigned int frac;
    frac = (flowRate - int(flowRate)) * 10;
    pulseCount = 0;
    attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
    Serial.print(totalMilliLitres); 
    Serial.println("mL");
      }
  }
  Iniciar(); 
}

//************* Inicio de la conexion GPRS ********//
void Iniciar()
{
  enviarAT("AT+CPIN?", "OK", 6000);                       //------------------------------------------------------------ Determinando el PIN del SIM CARD.
  Serial.println("Conectando a la red...");
  delay (5000);
  enviarAT("AT+CSQ", "OK", 3000);                         //------------------------------------------------------------ Midiendo la calidad de la senal, 15 a mas, es muy buena.
  while ( enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 0 ) //------------------------------------------------------------ Espera hasta estar conectado a la red movil
  {
  //DataLogger();                                           //------------------------------------------------------------ Si no se encuetra la red, se activa la funcion de Datalogguer
  }
  Serial.println("Conectado a la red.");
  enviarAT("AT+CGATT?", "OK", 2000);                      //------------------------------------------------------------ Iniciamos la conexión GPRS
  enviarAT("AT+CGATT=1\r", "OK", 2000);                   //------------------------------------------------------------ Activamos la conexión GPRS
  enviarAT("AT+CGCLASS?", "OK", 3000);                   //------------------------------------------------------------ Configurarmos el SIM900 de acuerdo a la clase de GPRS a usar.
  enviarAT("AT+CSTT=\"web.emovil\",\"webemovil\",\"webemovil\"", "OK", 3000);           //------------------------------ Configuramos la APN a usar para la comunicacion
  enviarAT("AT+CSTT=\"CMNET\"", "OK", 3000);              ////----------------------------------------------------------- Activamos la APN
  enviarAT("AT+CIICR", "OK", 3000);                       //------------------------------------------------------------//Activamos la conexion inalambrica
  enviarAT("AT+CIFSR", "", 4000);                         //------------------------------------------------------------//Se obtiene la direccion IP local
  Sensor1();
}
//*********************************************//

//////////////////////////////////////////////////////////////////////////////
void Sensor1()
{
  float Flujo=totalMilliLitres;
  char str[6];
  char direccion[50];
  dtostrf(Flujo, 6, 1, str);
  sprintf(direccion, "GET /update?api_key=WKPNL40975OI2JI1&field4=%s HTTP/1.1\r\nHost: api.thingspeak.com\r\nConnection: close\r\n\r\n", str);
  
  if (enviarAT("AT+CREG?", "+CREG: 0,1", 6000) == 1)  
  { //Comprueba la conexion a la red 
      enviarAT("AT+CIPSTART=\"TCP\",\"184.106.153.149\",\"80\"", "CONNECT OK", 5000); //Inicia una conexión TCP
      // Envíamos datos a través del TCP

      sprintf(aux_str, "AT+CIPSEND=%d", strlen(direccion));
      if (enviarAT(aux_str, ">", 10000) == 1) {
          enviarAT(direccion, "OK", 5000);
          enviarAT("AT+CIPCLOSE", "OK", 3000);
          enviarAT("AT+CIPSHUT\r", "OK", 3000);
          Serial.println("Envio de Datos satisfactorio");
          delay(4000);
      }
      
  }
  else  
  {
      Serial.println("Error en el envio");
  }
} 
//*********************************************//


void pulseCounter()
{
  pulseCount++;
}

//***** VALIDAR QUE LOS COMANDOS AT FUERON ENVADOS ******//
int enviarAT(String ATcommand, char* resp_correcta, unsigned int tiempo)
{
  int x = 0;
  bool correcto = 0;
  char respuesta[100];
  unsigned long anterior;
  memset(respuesta, '\0', 100);   //---------------------------- Inicializa el string
  delay(100);
  while ( SIM900.available() > 0) SIM900.read();    //--------- Limpia el buffer de entrada
  SIM900.println(ATcommand);      //--------------------------- Envia el comando AT
  x = 0;
  anterior = millis();
  // Espera una respuesta
  do {
    // si hay datos el buffer de entrada del UART lee y comprueba la respuesta
    if (SIM900.available() != 0)
    {
        respuesta[x] = SIM900.read();
        x++;
      // Comprueba si la respuesta es correcta
      if (strstr(respuesta, resp_correcta) != NULL)
      {
        correcto = 1;
      }
    }
  }
  // Espera hasta tener una respuesta
  while ((correcto == 0) && ((millis() - anterior) < tiempo));
  Serial.println(respuesta);

  return correcto;
}
//*********************************************//

Gracias por vuestra opinión y comentario.

Prueba esta versión. Uso un contador llamado cont que se incrementa cada 1000 mseg
Cuando superes 10 entonces comienza a enviar.

#include <SoftwareSerial.h>
SoftwareSerial SIM900(10, 11);

// -----------------SIM900--------------
int respuesta;
char aux_str[50];
//------------------------------------------------------------------

//Pines de Entrada Sensor de Flujo
//----------------------------------------------
byte statusLed    = 13;
float litros=0;
byte sensorInterrupt = 0;
byte sensorPin       = 2;
float calibrationFactor = 7.150;
volatile byte pulseCount;  
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;
unsigned int cont = 0;


//--------------------- Setup General --------------------------//
void setup()
{
  Serial.begin(19200);     

//************* Sensor de Flujo ********//
  pinMode(statusLed, OUTPUT);
  digitalWrite(statusLed, HIGH);
  pinMode(sensorPin, INPUT);
  digitalWrite(sensorPin, HIGH);
  pulseCount        = 0;
  flowRate          = 0.0;
  flowMilliLitres   = 0;
  totalMilliLitres  = 0;
  oldTime           = 0;
  attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
//***********************************

//************* SIM900 ********//
  SIM900.begin(19200);          
  delay(1000);
  Serial.println("Iniciando...");                   
}
//------------------------------------------------------------------//

void loop()
{
  while (totalMilliLitres == 0)  {
    if ((millis() - oldTime) > 1000) { 
        detachInterrupt(sensorInterrupt);
        flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
        flowMilliLitres = (flowRate / 60) * 1000;
        totalMilliLitres += flowMilliLitres;
        unsigned int frac;
        frac = (flowRate - int(flowRate)) * 10;
        pulseCount = 0;
        oldTime = millis();
        attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
        Serial.print(totalMilliLitres); 
        Serial.println("mL");
        cont++;
    }
  }
  if (cont=>10)
      Iniciar(); 
}

//************* Inicio de la conexion GPRS ********//
void Iniciar() {
  enviarAT("AT+CPIN?", "OK", 6000);                       //------------------------------------------------------------ Determinando el PIN del SIM CARD.
  Serial.println("Conectando a la red...");
  delay (5000);
  enviarAT("AT+CSQ", "OK", 3000);                         //------------------------------------------------------------ Midiendo la calidad de la senal, 15 a mas, es muy buena.
  while ( enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 0 ) {//------------------------------------------------------------ Espera hasta estar conectado a la red movil
        //DataLogger();                                           //------------------------------------------------------------ Si no se encuetra la red, se activa la funcion de Datalogguer
  }
  Serial.println("Conectado a la red.");
  enviarAT("AT+CGATT?", "OK", 2000);                      //------------------------------------------------------------ Iniciamos la conexión GPRS
  enviarAT("AT+CGATT=1\r", "OK", 2000);                   //------------------------------------------------------------ Activamos la conexión GPRS
  enviarAT("AT+CGCLASS?", "OK", 3000);                   //------------------------------------------------------------ Configurarmos el SIM900 de acuerdo a la clase de GPRS a usar.
  enviarAT("AT+CSTT=\"web.emovil\",\"webemovil\",\"webemovil\"", "OK", 3000);           //------------------------------ Configuramos la APN a usar para la comunicacion
  enviarAT("AT+CSTT=\"CMNET\"", "OK", 3000);              ////----------------------------------------------------------- Activamos la APN
  enviarAT("AT+CIICR", "OK", 3000);                       //------------------------------------------------------------//Activamos la conexion inalambrica
  enviarAT("AT+CIFSR", "", 4000);                         //------------------------------------------------------------//Se obtiene la direccion IP local
  Sensor1();
}
//*********************************************//

//////////////////////////////////////////////////////////////////////////////
void Sensor1()
{
  float Flujo=totalMilliLitres;
  char str[6];
  char direccion[50];
  dtostrf(Flujo, 6, 1, str);
  sprintf(direccion, "GET /update?api_key=WKPNL40975OI2JI1&field4=%s HTTP/1.1\r\nHost: api.thingspeak.com\r\nConnection: close\r\n\r\n", str);
  
  if (enviarAT("AT+CREG?", "+CREG: 0,1", 6000) == 1)  
  { //Comprueba la conexion a la red 
      enviarAT("AT+CIPSTART=\"TCP\",\"184.106.153.149\",\"80\"", "CONNECT OK", 5000); //Inicia una conexión TCP
      // Envíamos datos a través del TCP

      sprintf(aux_str, "AT+CIPSEND=%d", strlen(direccion));
      if (enviarAT(aux_str, ">", 10000) == 1) {
          enviarAT(direccion, "OK", 5000);
          enviarAT("AT+CIPCLOSE", "OK", 3000);
          enviarAT("AT+CIPSHUT\r", "OK", 3000);
          Serial.println("Envio de Datos satisfactorio");
          delay(4000);
      }
      
  }
  else  
  {
      Serial.println("Error en el envio");
  }
} 
//*********************************************//


void pulseCounter()
{
  pulseCount++;
}

//***** VALIDAR QUE LOS COMANDOS AT FUERON ENVADOS ******//
int enviarAT(String ATcommand, char* resp_correcta, unsigned int tiempo)
{
  int x = 0;
  bool correcto = 0;
  char respuesta[100];
  unsigned long anterior;
  memset(respuesta, '\0', 100);   //---------------------------- Inicializa el string
  delay(100);
  while ( SIM900.available() > 0) SIM900.read();    //--------- Limpia el buffer de entrada
  SIM900.println(ATcommand);      //--------------------------- Envia el comando AT
  x = 0;
  anterior = millis();
  // Espera una respuesta
  do {
    // si hay datos el buffer de entrada del UART lee y comprueba la respuesta
    if (SIM900.available() != 0)
    {
        respuesta[x] = SIM900.read();
        x++;
      // Comprueba si la respuesta es correcta
      if (strstr(respuesta, resp_correcta) != NULL)
      {
        correcto = 1;
      }
    }
  }
  // Espera hasta tener una respuesta
  while ((correcto == 0) && ((millis() - anterior) < tiempo));
  Serial.println(respuesta);

  return correcto;
}
//*********************************************//

Hola, si se queda enganchado en el while, es por que totalMilliLitres es siempre 0 (la condición se sigue cumpliendo), como cada segundo recalculas totalMilliLitres y además lo imprimes por consola, deberías ver en la consola como totalMilliLitres es siempre 0 y por eso no abandona el bucle, por tanto como totalMilliLitres se calcula en función del contador de la interrupción, te diría que no te está funcionando.

De todas formas mi consejo para que aprendas a solucionar estos errores es que uses Serial.print(nombre_variable) para ver que valor tiene la variable que te interesa en un momento dado y alguno delay(1000) para ver mejor los resultados en pantalla de la consola. Haz un Serial.println(pulseCount) justo después del while y así ves como se va incrementando el contador de pulsos conforme el fluido pase a través del sensor y la interrupción se vaya disparando, haz lo mismo para totalMilliLitres y se debe ir incrementando, cuando sea distinto de 0 dejará el bucle.

En fin, sketch de caudalimetros hay muchos que te pueden servir de ejemplos, pero yo te animaría a depurar tu programa para que aprendas mejor...ya sabes que si no abandona el while es por que totalMilliLitres no cambia y permanece a 0 en cada iteracción, ahora debes averiguar el por qué.

Y después para enviar cada diez segundos lo puedes hacer como te recomienda surbyte.

Saludos,

Cierto, no le presté la atención debida a ese while. Quítalo para que la rutina permita calcular totalMilliLitres y luego del 10mo envíe datos cada 1 segundo OJO!!! si quieres que sea solo cada 10 segundos entonces pon a 0 la variable contador que te agregué.

Saludes a todos, disculpad por no haber confirmado si la ayuda había funcionado oh no, y en efecto funcionó al 100, Muchas gracias alfredomrh y surbyte por vuestra ayuda y paciencia.

Estuve editando el código y agregue una instancia en donde luego de haber leído la variable que iba a enviar, la guardara en otra variable para asi compararla con el siguiente valor que se leyera, si el valor era 0 (es decir que no había flujo) me enviase la variable con el valor previamente leído.

Pero no logre hacer que me funcionara, os agrego el código, no sé en que estoy errado. Lo he colocado de varias formas pero no me logra funcionar, al leer 0 en vez de mandarme el valor en la variable anterior, me envía 0.

Las variables fueron Lecact y Lecant, en donde Lecant es lectura anterior y Lecact es lectura actual.

#include <SoftwareSerial.h>
SoftwareSerial SIM900(10, 11);

// -----------------SIM900--------------
int respuesta;
char aux_str[50];
//--------------------------------------

//Pines de Entrada Sensor de Flujo
//-------------------------------------------------------------
byte statusLed    = 13;
float litros=0;
byte sensorInterrupt = 0;
byte sensorPin       = 2;
float calibrationFactor = 7.150;
volatile byte pulseCount;  
float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
unsigned long oldTime;
unsigned long Lecant = 0;
unsigned long Lecact = 0;
unsigned int cont = 0;
//--------------------- Setup General --------------------------//
void setup()
{
  Serial.begin(19200);     

//************* Sensor de Flujo ********//
  pinMode(statusLed, OUTPUT);
  digitalWrite(statusLed, HIGH);
  pinMode(sensorPin, INPUT);
  digitalWrite(sensorPin, HIGH);
  pulseCount        = 0;
  flowRate          = 0.0;
  flowMilliLitres   = 0;
  totalMilliLitres  = 0;
  oldTime           = 0;
  attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
//***********************************

//************* SIM900 ********//
  SIM900.begin(19200);          
  delay(1000);
  Serial.println("Iniciando...");                   
}
//------------------------------------------------------------------//

void loop()
{
      if ((millis() - oldTime) > 1000) 
    { 
        detachInterrupt(sensorInterrupt);
        flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
        flowMilliLitres = (flowRate / 60) * 1000;
        totalMilliLitres += flowMilliLitres;
        unsigned int frac;
        frac = (flowRate - int(flowRate)) * 10;
        pulseCount = 0;
        oldTime = millis();
        attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
        Serial.print(totalMilliLitres); 
        Serial.println("mL");
        Lecact = totalMilliLitres;
        cont++;
    }
  
  if (cont>=10)
  {
      Iniciar(); 
  }
}

//************* Inicio de la conexion GPRS ********//
void Iniciar() 
{
  enviarAT("AT+CPIN?", "OK", 6000);                      
  Serial.println("Conectando a la red...");
  delay (5000);
  enviarAT("AT+CSQ", "OK", 3000);                         
  while ( enviarAT("AT+CREG?", "+CREG: 0,1", 1000) == 0 ) 
  {
        //DataLogger();                                           
  }
  Serial.println("Conectado a la red.");
  enviarAT("AT+CGATT?", "OK", 2000);                      
  enviarAT("AT+CGATT=1\r", "OK", 2000);                  
  enviarAT("AT+CGCLASS?", "OK", 3000);                   
  enviarAT("AT+CSTT=\"web.emovil\",\"webemovil\",\"webemovil\"", "OK", 3000);  
  enviarAT("AT+CSTT=\"CMNET\"", "OK", 3000);          
  enviarAT("AT+CIICR", "OK", 3000);                      
  enviarAT("AT+CIFSR", "", 4000);                         
  Sensor1();
}
//*********************************************//

//////////////////////////////////////////////////////////////////////////////
void Sensor1()
{
  if (Lecact > 0)
  {
  float Flujo= Lecact;
  Lecant=Lecact;
  char str[6];
  char direccion[50];
  dtostrf(Flujo, 6, 1, str);
  sprintf(direccion, "GET /update?api_key=CXQI49ANHUJDXG6P&field4=%s HTTP/1.1\r\nHost: api.thingspeak.com\r\nConnection: close\r\n\r\n", str);
  
  if (enviarAT("AT+CREG?", "+CREG: 0,1", 6000) == 1)  
    { //Comprueba la conexion a la red 
      enviarAT("AT+CIPSTART=\"TCP\",\"184.106.153.149\",\"80\"", "CONNECT OK", 5000); 

      sprintf(aux_str, "AT+CIPSEND=%d", strlen(direccion));
      if (enviarAT(aux_str, ">", 10000) == 1) 
      {
          enviarAT(direccion, "OK", 5000);
          enviarAT("AT+CIPCLOSE", "OK", 3000);
          enviarAT("AT+CIPSHUT\r", "OK", 3000);
          Serial.println("Envio de Datos satisfactorio");
          delay(4000); 
      }
    } 
  else  
    {
      Serial.println("Error en el envio");
    }
  }

  else
  { 
  float Flujo= Lecant;
  char str[6];
  char direccion[50];
  dtostrf(Flujo, 6, 1, str);
  sprintf(direccion, "GET /update?api_key=CXQI49ANHUJDXG6P&field4=%s HTTP/1.1\r\nHost: api.thingspeak.com\r\nConnection: close\r\n\r\n", str);
  
    if (enviarAT("AT+CREG?", "+CREG: 0,1", 6000) == 1)  
      { //Comprueba la conexion a la red 
        enviarAT("AT+CIPSTART=\"TCP\",\"184.106.153.149\",\"80\"", "CONNECT OK", 5000);

        sprintf(aux_str, "AT+CIPSEND=%d", strlen(direccion));
        if (enviarAT(aux_str, ">", 10000) == 1) 
         {
          enviarAT(direccion, "OK", 5000);
          enviarAT("AT+CIPCLOSE", "OK", 3000);
          enviarAT("AT+CIPSHUT\r", "OK", 3000);
          Serial.println("Envio de Datos satisfactorio");
          delay(4000);
         }   
        }
    else  
      {
      Serial.println("Error en el envio");
      }
  }
} 
//*********************************************//


void pulseCounter()
{
  pulseCount++;
}

//***** VALIDAR QUE LOS COMANDOS AT FUERON ENVADOS ******//
int enviarAT(String ATcommand, char* resp_correcta, unsigned int tiempo)
{
  int x = 0;
  bool correcto = 0;
  char respuesta[100];
  unsigned long anterior;
  memset(respuesta, '\0', 100);   //---------------------------- Inicializa el string
  delay(100);
  while ( SIM900.available() > 0) SIM900.read();    //--------- Limpia el buffer de entrada
  SIM900.println(ATcommand);      //--------------------------- Envia el comando AT
  x = 0;
  anterior = millis();
  // Espera una respuesta
  do {
    // si hay datos el buffer de entrada del UART lee y comprueba la respuesta
    if (SIM900.available() != 0)
    {
        respuesta[x] = SIM900.read();
        x++;
      // Comprueba si la respuesta es correcta
      if (strstr(respuesta, resp_correcta) != NULL)
      {
        correcto = 1;
      }
    }
  }
  // Espera hasta tener una respuesta
  while ((correcto == 0) && ((millis() - anterior) < tiempo));
  Serial.println(respuesta);

  return correcto;
}

Me podrían ayudar diciéndome que estoy haciendo mal? Agradezco vuestra ayuda de antemano.
Quedo atento a vuestros comentarios.

N.A.V

Hola, prueba a poner:

char direccion[192];

mas vale que sobre jejeje

Mi opinión es que debes refactorizar mucho tu código, eliminar variables intermedias que no necesitas y varias cosas más. Mira en este código que he pegado, lees el contador de pulsos y vas acumulando el caudal, en totalMiliLitres, que es una variable que nunca vuelves a poner a cero, por lo tanto su valor solo va creciendo mientras el arduino siga encendido.

No lo he mirado muy detenidamente, pero creo que el principal error debe de estar en la cadena REST que envias a thingspeak o en las conversiones que haces antes. Lo digo por que una vez haya enviado un valor positivo, nunca debería volver a ser cero. También creo veo que conviertes el valor en string antes del fsprint, cosa que no creo necesaria (&fieldX=%f y le pones tu variable float directamente).

Por otra parte, yo lo haría asi: entro dentro del if cada segundo como haces, y hago el calculo, si el valor de totalmililitres no ha cambiado, sigo en loop repitiendo el proceso, si ha aumentado entonces envio la información. Asi creo que debería ser la lógica de tu sketch.

void loop()
{
      if ((millis() - oldTime) > 1000) 
      { 

        ml_Anterior = totalMiliLitres;          

        detachInterrupt(sensorInterrupt);
        flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;
        flowMilliLitres = (flowRate / 60) * 1000;
        totalMilliLitres += flowMilliLitres;
        unsigned int frac;
        frac = (flowRate - int(flowRate)) * 10;
        pulseCount = 0;
        oldTime = millis();
        attachInterrupt(sensorInterrupt, pulseCounter, FALLING);

        //debes abrir la consola para ver los valores que se imprimen aqui, y comprobar que son correctos
        //acorde al flujo, solo cuando el caudal haya aumentado se enviara

        Serial.print(ml_Anterior); 
        Serial.println("mL Anteriores");
        Serial.print(totalMilliLitres); 
        Serial.println("mL");
       
    }
  
  if (totalMiliLitres>ml_Anterior)
  {
      Iniciar(); //solo si ha aumentado el caudal envias, si no sigues en el loop
  }
}

Prueba a poner esta instruccion despues de sprintf y así comprobar la longitud del string que usas para la solicitud, ya que tu reservas [50] y se te pasas, se empiezan a producir errores de memoria que son extraños, pero este es un error muy comun.

 printf("longitud de mi solicitud asi rest %d\n", strlen(direccion));

Al menos debes reservar el tamaño que te imprima en la consola esta instruccion, es decir, char direccion[tamañodemisolicitud];

Mira este esta es la solicitud http que utilizo para actualizar un canal de thingspeak.

sprintf(mi_solicitud,
            "GET /update?key=%s&field1=%d&field2=%d&field3=%d&field4=%d&field5=%f&field6=%f&field7=%f HTTP/1.1\nHost: %s\nConnection:close\nUser-Agent: ESP32 / esp-idf\n\n",
            CONFIG_WRITE_API_KEY, var_entera, var_entera2, idem, otra, temp, tempAmb, humAmb, CONFIG_WEB_SERVER);

como verás uso variables tipo entero y float directamente.

Espero te sirva. Saludos.