BLYNK
HOME       📲 GETTING STARTED       📗 DOCS       ❓HELP CENTER       👉 SKETCH BUILDER

Data is received with delay on Blynk app

Hello everyone ,
I’m new around here and with blynk.

I’m using an Arduino UNO and ESP8266.
I am using the latest Android and version of app.

ESP is connected to 3.3V and with level shifter for RX /TX .
CH_PD is connected to 3.3V via a resistor.

The Esp has v0.9.2.2 AT Firmware installed .

I have a issues with receiving the data to blynk app with delay.

if i set 5 s or 10 s for timer i get the data updated on app after 20-40 seconds.
and also I don’t know why it does not send the correct values.
The code is tested and is working good and the values are correct from sensors. ( via Serial monitor).
Also i had to comment out all the serial. Print because they are not working and is making the esp disconnect and reconnect non-stop.

Any suggestions or directions would be appreciated.


#define BLYNK_PRINT Serial


#include <ESP8266_Lib.h>
#include <BlynkSimpleShieldEsp8266.h>

char auth[] = "XXXXXXX";
char ssid[] = "XXXXXXX";
char pass[] = "XXXXXX";

#include <SoftwareSerial.h>
SoftwareSerial EspSerial(10, 11); // RX, TX

#define ESP8266_BAUD 9600
ESP8266 wifi(&EspSerial);
BlynkTimer timer;

        /* 0- General */

        int decimalPrecision = 2;                         // decimal places for all values shown in LED Display & Serial Monitor

        /* 1- AC Voltage Measurement */
        
        int VoltageAnalogInputPin = A2;                   // Which pin to measure voltage Value
        float voltageSampleRead  = 0;                     /* to read the value of a sample*/
        float voltageLastSample  = 0;                     /* to count time for each sample. Technically 1 milli second 1 sample is taken */
        float voltageSampleSum   = 0;                     /* accumulation of sample readings */
        float voltageSampleCount = 0;                     /* to count number of sample. */
        float voltageMean ;                               /* to calculate the average value from all samples*/ 
        float RMSVoltageMean ;                            /* square roof of voltageMean*/

              /*1.1 Offset AC Voltage */
    
              int voltageOffsetRead = 0;                  /* to change the mode for offset */
              float voltageOffset1 = 0;                   // to Offset deviation and accuracy. Offset any fake current when no current operates. 
                                                          // Offset will automatically callibrate when SELECT Button on the LCD Display Shield is pressed.
                                                          // If you do not have LCD Display Shield, look into serial monitor to add or minus the value manually and key in here.
              float voltageOffset2 = 0;                   // to offset value due to calculation error from squared and square root.
              float voltageSampleSumOffset =0;            /* accumulation of sample readings for offset */
              float offsetVoltageMean = 0;                /* to calculate the average value from all samples for offset, in analog values*/
              float voltageOffsetLastSample = 0;          /* to count time for each sample for offset purpose. */
              float voltageOffsetSampleCount = 0;         /* to count number of sample for offset. */


        /* 2- AC Current Measurement */

        int CurrentAnalogInputPin = A0;                   // Which pin to measure Current Value
        float mVperAmpValue = 33.33;                      // If using ACS712 current module : for 5A module key in 185, for 20A module key in 100, for 30A module key in 66
                                                          // If using "Hall-Effect" Current Transformer, key in value using this formula: mVperAmp = maximum voltage range (in milli volt) / current rating of CT
                                                          /* For example, a 20A Hall-Effect Current Transformer rated at 20A, 2.5V +/- 0.625V, mVperAmp will be 625 mV / 20A = 31.25mV/A */
        float currentSampleRead  = 0;                     /* to read the value of a sample*/
        float currentLastSample  = 0;                     /* to count time for each sample. Technically 1 milli second 1 sample is taken */
        float currentSampleSum   = 0;                     /* accumulation of sample readings */
        float currentSampleCount = 0;                     /* to count number of sample. */
        float currentMean ;                               /* to calculate the average value from all samples*/ 
        float RMSCurrentMean =0 ;                         /* square roof of currentMean*/
        float FinalRMSCurrent ;                           /* the final RMS current reading*/


              /*2.1 Offset AC Current */
    
              int currentOffsetRead = 0;                  /* to change the mode for offset */
              float currentOffset1 = 0;                   // to Offset deviation and accuracy. Offset any fake current when no current operates. 
                                                          // Offset will automatically callibrate when SELECT Button on the LCD Display Shield is pressed.
                                                          // If you do not have LCD Display Shield, look into serial monitor to add or minus the value manually and key in here.
                                                          // 26 means add 26 to all analog value measured
              float currentOffset2 = 0;                   // to offset value due to calculation error from squared and square root.
              float currentSampleSumOffset = 0;           /* accumulation of sample readings for offset */
              float offsetCurrentMean = 0;                /* to calculate the average value from all samples for offset, in analog values*/
              float currentOffsetLastSample = 0;          /* to count time for each sample for offset purpose. */
              float currentOffsetSampleCount = 0;         /* to count number of sample for offset. */


        /* 3- AC Power Measurement */
        
        float sampleCurrent1 ;                            /* use to calculate current*/
        float sampleCurrent2 ;                            /* use to calculate current*/
        float sampleCurrent3 ;                            /* use to calculate current*/
        float apparentPower;                              /* the apparent power reading (VA) */
        float realPower = 0;                              /* the real power reading (W) */
        float powerSampleRead  = 0;                       /* to read the current X voltage value of a sample*/
        float powerLastSample   = 0;                      /* to count time for each sample. Technically 1 milli second 1 sample is taken */       
        float powerSampleCount  = 0;                      /* to count number of sample. */
        float powerSampleSum    = 0;                      /* accumulation of sample readings */         
        float powerFactor = 0;                            /* to display power factor value*/ 


              /*3.1 Offset AC Power */
    
              int powerOffsetRead = 0;                    /* to change the mode for offset */
              float powerOffset = 0;                      // to Offset deviation and accuracy. Offset any fake current when no current operates. 
                                                          // Offset will automatically callibrate when SELECT Button on the LCD Display Shield is pressed.
                                                          // If you do not have LCD Display Shield, look into serial monitor to add or minus the value manually and key in here.
              float powerOffsetLastSample = 0;            /* to count time for each sample for offset purpose. */
              float powerOffsetSampleCount = 0;           /* to count number of sample for offset. */

        
    void Event()
{
 Blynk.virtualWrite(V1,RMSVoltageMean);
 Blynk.virtualWrite(V2,FinalRMSCurrent);
 Blynk.virtualWrite(V3,powerFactor);
 Blynk.virtualWrite(V4,realPower);
 Blynk.virtualWrite(V5,apparentPower);
}
void timp ()
{
 Blynk.virtualWrite(V0,millis()/1000);
}



void setup()                                              /*codes to run once */

{                                      

  // Debug console
  Serial.begin(115200);

  // Set ESP8266 baud rate
  EspSerial.begin(ESP8266_BAUD);
  

  Blynk.begin(auth, wifi, ssid, pass);
  // You can also specify server:
  //Blynk.begin(auth, wifi, ssid, pass, "blynk-cloud.com", 80);
  //Blynk.begin(auth, wifi, ssid, pass, IPAddress(192,168,1,100), 8080);

  // Setup a function to be called every second
  timer.setInterval(20000L, Event);

  timer.setInterval(1000L, timp);

}


void loop()                                                                                       /*codes to run again and again */
{                                      

        /* 0- General */


              /* 0.1- Button Function */
              int buttonRead;
              buttonRead = analogRead (5); 
             
                                                              

            if (buttonRead > 800)
            {
              currentOffsetRead = 1;                                                              // to activate offset for current  
              voltageOffsetRead = 1;                                                              // to activate offset for voltage
              powerOffsetRead = 1;                                                                // to activate offset for power
                                                                      /* set display words starting at upper left corner*/
            //  Serial.print ("INITIALIZING..... ");
                                                                             /* set display words starting at lower left corner*/
            //  Serial.print ("WAIT 5 SEC ..... ");
              }

        /* 1- AC Voltage Measurement */
 
        if(millis() >= voltageLastSample + 1 )                                                    /* every 1 milli second taking 1 reading */
          {
            voltageSampleRead = 2*(analogRead(VoltageAnalogInputPin)- 512) + voltageOffset1;      /* read the sample value */
            voltageSampleSumOffset = voltageSampleSumOffset + voltageSampleRead;                  /* values accumulate for offset purpose every milli second */
            
            voltageSampleSum = voltageSampleSum + sq(voltageSampleRead) ;                         /* accumulate value with older sample readings*/     
            voltageSampleCount = voltageSampleCount + 1;                                          /* to move on to the next following count */
            voltageLastSample = millis() ;                                                        /* to reset the time again so that next cycle can start again*/ 
          }
        
        if(voltageSampleCount == 1000)                                                            /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
          {
            offsetVoltageMean = voltageSampleSumOffset/voltageSampleCount;                        /* average the offset reading*/
            
            voltageMean = voltageSampleSum/voltageSampleCount;                                    /* calculate average value of all sample readings taken*/
            RMSVoltageMean = sqrt(voltageMean)+ voltageOffset2;                                   /* square root of the average value*/
            
           Serial.print(" The Voltage RMS value is: ");
           Serial.print(RMSVoltageMean,decimalPrecision);
           Serial.println(" V ");
            voltageSampleSum =0;                                                                  /* to reset accumulate sample values for the next cycle */
            voltageSampleCount=0;                                                                 /* to reset number of sample for the next cycle */
            voltageSampleSumOffset=0;
          }
 

              /* 1.1 - Offset AC Voltage */
                  
              if(voltageOffsetRead == 1)                                                          /* Run this code when button SELECT is pressed */
                {
                  voltageOffset1 = 0; 
                  if(millis()>= voltageOffsetLastSample + 1)                                      /* keep countng time for offset1*/
                    {                                                                            
                      voltageOffsetSampleCount = voltageOffsetSampleCount + 1;                    /* 1 milli second add 1 count*/                                                      
                      voltageOffsetLastSample = millis();                                         /* to reset the time again so that next cycle can start again*/                                  
                    }                                                                                 
                  if(voltageOffsetSampleCount == 2000)                                            /* after 2 seconds, run this codes.  */
                    {                                                                            
                      voltageOffset1 = -1*(offsetVoltageMean);                                    /* set the offset values */
                      voltageOffsetRead = 2;                                                      /* go for second offset Settings */                     
                      voltageOffsetSampleCount = 0;                                               /* to reset the time again so that next cycle can start again */                                                             
                    } 
                }   
                    
              if(voltageOffsetRead == 2)                                                          /* Run this code after first offset done */
                {
                  voltageOffset2 = 0;                                                             /* set back currentOffset2 as default*/
                  if(millis()>= voltageOffsetLastSample + 1)                                      /* keep countng time for offset2*/
                    {                                                                            
                      voltageOffsetSampleCount = voltageOffsetSampleCount + 1;                                                                          
                      voltageOffsetLastSample = millis();                                                                          
                    }                                                                                
                  if(voltageOffsetSampleCount == 2000)                                            /* after 2 seconds, run this codes.  */
                    {                                                                            
                      voltageOffset2 = - RMSVoltageMean;                                          /* set the offset values */
                      voltageOffsetRead = 0;                                                      /* change the offset mode to original, wait until the button is pressed again */                     
                      voltageOffsetSampleCount = 0;                                               /* to reset the time again so that next cycle can start again */ 
                    }                                                                             
                } 


        /* 2- AC Current Measurement */
        
        if(millis() >= currentLastSample + 1)                                                     /* every 1 milli second taking 1 reading */
          {
            currentSampleRead = analogRead(CurrentAnalogInputPin)-512 + currentOffset1;           /* read the sample value */
            
            currentSampleSumOffset = currentSampleSumOffset + currentSampleRead;                  /* accumulate offset value */
            
            currentSampleSum = currentSampleSum + sq(currentSampleRead) ;                         /* accumulate value with older sample readings*/
            currentSampleCount = currentSampleCount + 1;                                          /* to move on to the next following count */
            currentLastSample = millis();                                                         /* to reset the time again so that next cycle can start again*/ 
          }
        
        if(currentSampleCount == 1000)                                                            /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
          {
            offsetCurrentMean = currentSampleSumOffset/currentSampleCount;                        /* average offset value*/
            
            currentMean = currentSampleSum/currentSampleCount;                                    /* calculate average value of all sample readings taken*/
            RMSCurrentMean = sqrt(currentMean)+currentOffset2 ;                                   /* square root of the average value*/
            FinalRMSCurrent = (((RMSCurrentMean /1024) *5000)/ mVperAmpValue );                    /* calculate the final RMS current*/
          //  Serial.print(" The Current RMS value is: ");
          
          //  Serial.print(FinalRMSCurrent,decimalPrecision);
          //  Serial.println(" A ");
            currentSampleSum =0;                                                                  /* to reset accumulate sample values for the next cycle */
            currentSampleCount=0;                                                                 /* to reset number of sample for the next cycle */
            currentSampleSumOffset=0;                                                             /* to reset accumulate offset value for the next cycle*/
          }

              /* 2.1 - Offset AC Current */
                  
              if(currentOffsetRead == 1)                                                          /* Run this code when button SELECT is pressed */
                {
                  currentOffset1 = 0;                                                             /* set currentOffset back to default value*/
                  if(millis()>= currentOffsetLastSample + 1)                                      /* keep countng time for offset1*/
                    {                                                                            
                      currentOffsetSampleCount = currentOffsetSampleCount + 1;                                                                          
                      currentOffsetLastSample = millis();                                                                          
                    }                                                                                 
                  if(currentOffsetSampleCount == 2000)                                            /* after 2 seconds, run this codes.  */
                    {                                                                            
                      currentOffset1 = - offsetCurrentMean;                                       /* set the offset values */
                      currentOffsetRead = 2;                                                      /* go for second offset Settings */                     
                      currentOffsetSampleCount = 0;                                               /* to reset the time again so that next cycle can start again */                                                             
                    } 
                }   
                
              if(currentOffsetRead == 2)                                                          /* Run this code after first offset done */
                {
                  currentOffset2 = 0;                                                             /* set back currentOffset2 as default*/
                  if(millis()>= currentOffsetLastSample + 1)                                      /* keep countng time for offset2*/
                    {                                                                            
                      currentOffsetSampleCount = currentOffsetSampleCount + 1;                                                                          
                      currentOffsetLastSample = millis();                                                                          
                    }                                                                             
                          
                  if(currentOffsetSampleCount == 2000)                                            /* after 2 seconds, run this codes.  */
                    {                                                                            
                      currentOffset2 = - RMSCurrentMean;                                          /* set the offset values */
                      currentOffsetRead = 0;                                                      /* change the offset mode to original, wait until the button is pressed again */                     
                      currentOffsetSampleCount = 0;                                               /* to reset the time again so that next cycle can start again */ 
                    }                                                                             
                } 
       
        /* 3- AC Power with Direction */

        if(millis() >= powerLastSample + 1)                                                       /* every 1 milli second taking 1 reading */
          {
            sampleCurrent1 = analogRead(CurrentAnalogInputPin)-512+ currentOffset1;
            sampleCurrent2 = (sampleCurrent1/1024)*5000;
            sampleCurrent3 = sampleCurrent2/mVperAmpValue;
            voltageSampleRead = 2*(analogRead(VoltageAnalogInputPin)- 512)+ voltageOffset1 ;
            powerSampleRead = voltageSampleRead * sampleCurrent3 ;                                /* real power sample value */
            powerSampleSum = powerSampleSum + powerSampleRead ;                                   /* accumulate value with older sample readings*/
            powerSampleCount = powerSampleCount + 1;                                              /* to move on to the next following count */
            powerLastSample = millis();                                                           /* to reset the time again so that next cycle can start again*/ 
          }
        
        if(powerSampleCount == 1000)                                                              /* after 1000 count or 1000 milli seconds (1 second), do the calculation and display value*/
          {
            realPower = ((powerSampleSum/powerSampleCount)+ powerOffset) ;                        /* calculate average value of all sample readings */
           // Serial.print(" The Real Power (W) is: ");
           // Serial.print(realPower);
          //  Serial.println(" W ");           
            apparentPower= FinalRMSCurrent*RMSVoltageMean;                                       /*Apparent power do not need to recount as RMS current and RMS voltage values available*/
           // Serial.print(" The Apparent Power (VA) is: ");
         //   Serial.print(apparentPower,decimalPrecision);
        //    Serial.println(" VA ");
            powerFactor = realPower/apparentPower;    
            if(powerFactor >1 || powerFactor<0)
            {
              powerFactor = 0;
            }
        //    Serial.print(" The Power Factor is: ");
       //     Serial.println(powerFactor,decimalPrecision);                                             
            powerSampleSum =0;                                                                    /* to reset accumulate sample values for the next cycle */
            powerSampleCount=0;                                                                   /* to reset number of sample for the next cycle */
          }
 

              /* 3.1 - Offset AC Power */

              if(powerOffsetRead == 1)                                                            /* Run this code after first offset done */
                {                          
                  powerOffset = 0;                                                                /* set back currentOffset2 as default*/
                  if(millis()>= powerOffsetLastSample + 1)                                        /* keep countng time for offset2*/
                    {                                                                            
                      powerOffsetSampleCount = powerOffsetSampleCount + 1;                                                                          
                      powerOffsetLastSample = millis();                                                                          
                    }                                                                                                      
                  if(powerOffsetSampleCount == 5000)                                              /* after 5 seconds, run this codes.  */
                    {                                                                            
                      powerOffset = -realPower;                                                
                      powerOffsetRead = 0;                                                        /* change the offset mode to original, wait until the button is pressed again */                     
                      powerOffsetSampleCount = 0;                                                 /* to reset the time again so that next cycle can start again */ 
                    }                                                                             
                } 


       

  Blynk.run();
  timer.run(); // Initiates BlynkTimer
    
}

You’re trying to run four functions from your void loop every time it executes. Your Uno can’t execute these functions as quickly as you think.
You need to call these functions using a timer, and give them sufficient time to complete before trying to do anything else.

Pete.

Changed the initial posted code to the one that using serial monitor is working great. i get values updated via serial monitor each second and the values are close to reality ( checked with a amp and volt meter).
The issue that i have is that i receive the data to blynk app with a 20 to 40 seconds delay. even if the times is set at 10-15 or 20 seconds to send the data to app.

I want to know why is this delay and why i cant lower the interval to 5 seconds .

All you appear to have done is to move the code out of your four functions directly into the void loop.
This doesn’t change the amount of code that has to be processed on each cycle through the void loop, which is where at least one of your problems lie.

Pete.