BLYNK
BLYNK.IO       📲 GETTING STARTED       📗 DOCS       👉 SKETCH BUILDER

Connection to Blynk server does not work

Hi,
Using Blynk 1.1.0, Blynk server, Arduino Uno, Mkr Ethernet shield.

A few months ago I had this running and everything worked perfectly. Both communication with app and device behaved exactly as expected. After that I tried another Ethernet shield but ended up using the Mkr shield again. But now, the connection to Blynk server does not work. Somehow it seems to connect and reconnect, sometimes it seems to be connected for a very short while but it simply does not work. Since device can connect to server I think the Ethernet/IP part is ok. Do I have the wrong Blynk version? I can’t see the difference compared to when it worked.

In attached image one can see the periodic connections to server, probably they are symptom of the root cause.

Br Björn

/*************************************************************

 Styrning av värmepump
 
 *************************************************************/
#define BLYNK_PRINT Serial 

// Blynk-items
#define BLYNK_TEMPLATE_ID           "TMPLQsUn1mZj"
#define BLYNK_DEVICE_NAME           "Test"
#define BLYNK_AUTH_TOKEN            "Dx3UwvsBNKVtv7dFLIYI-3Ec0mV3IOGo"
    
#include <SPI.h>
#include <Ethernet.h>
#include <BlynkSimpleEthernet.h>

char auth[] = BLYNK_AUTH_TOKEN;

#define SDCARD_CS 4

// Uppstartsfördröjning START_DELAY * 1 s
// Ska sättas till 60 sekunder när systemet är live
// Routern verkar hitta koppling efter cirka 35 sekunder
#define START_DELAY 5

//*************************************************************/

// Används för periodisk koll
BlynkTimer periodicTimer;

// Räknare för antalet checkar mot cloud
// Kör varje minut
// Låt dem nollas vid omstart
unsigned int connected = 0;
unsigned int not_connected = 0;

// Tröskel för låg temperatur
double lowTemp = 10;

// Aktivera autoavstängning vid låg temperatur
boolean activateLow = false;

// Räknare för periodisk timer
int periodicCount = 0;

// Antal minuter (59 sekunder) - periodtid, sätt för att vara under timmen
const int reportPeriod = 1; 

// Synkas alltid om
int currentLevel = 0;

// Förra samplet, sätt så att det inte triggar nerstängning
double lastVardagsrum = lowTemp + 1;   
double lastHall = lowTemp + 1;  

// Virtuella pinnar
// Sätta temperaturnivå : V0
// Visa temperaturnivå  : V1
// Hall                 : V2
// Utomhus              : V3
// Vardagsrum           : V4
// Uppkoppling stat.    : V5


// Kommer om pinne V0 (slider) ändrats eller om det är synkning. Sätt reläer.
BLYNK_WRITE(V0)
{  
  currentLevel = param.asInt();
  Serial.print("Fick nytt nivåvärde och skickat tillbaka till server: ");
  Serial.println(currentLevel);
  setLevel(currentLevel);
  Blynk.virtualWrite(V1, currentLevel);
}

// Synka värdet från server
BLYNK_CONNECTED()
{
   Blynk.syncVirtual(V0);
}

// Kör varje period
void timerHit()
{
  //---------------------------------------------------------------------------------
  
  // Kolla om en period gått, om inte, hoppa ur
  periodicCount++;

  if (periodicCount < reportPeriod)
  { 
    return;
  }
  //---------------------------------------------------------------------------------

  Serial.println("Kör periodisk funktion");
  
  // Eftersom en period gått, nolla räknaren
  periodicCount = 0;

  
  // Börja om ifall räknarna blivit stora
  if ( (connected > 65000) || (not_connected > 65000) )
  {
    connected = 0;
    not_connected = 0;
  }
  else
  {
  // Kolla om grejerna är uppe
  if (Blynk.connected() == true)
  {
    ++connected;
    Serial.println("Connected to server");
  }
  else
  {
    ++not_connected;
      Serial.println("Not connected to server");
  }

  // Undvik nolldivision samt uppdatera procentandel 
  int sum = connected+not_connected;
  
  if ( sum != 0 )
  {
    Blynk.virtualWrite(V5, 100*connected/sum);
  }
  } 

  //---------------------------------------------------------------------------------  
  
  // Temperaturer, kör tre mätningar per sensor
  double tempHall = calcTemperature(analogRead(0),analogRead(0),analogRead(0));
  
  double tempVardagsrum = calcTemperature(analogRead(1),analogRead(1),analogRead(1));
  
  double tempUte = calcTemperature(analogRead(2),analogRead(2),analogRead(2));
   
  // Uppdatera temperaturer till server
  Serial.println(tempHall);
  Serial.println(tempVardagsrum);
  Serial.println(tempUte);

  Blynk.virtualWrite(V1, currentLevel);
  
  Blynk.virtualWrite(V2, tempHall);

  Blynk.virtualWrite(V3, tempUte);

  Blynk.virtualWrite(V4, tempVardagsrum);

  // Om senaste och förra mätningen är för låga -> stäng av
  if ( ( ( (lastHall < lowTemp) && (tempHall < lowTemp)) || ( (tempVardagsrum < lowTemp) && (tempVardagsrum < lowTemp)) ) && activateLow == true )
  {
    // Larma bara här
  }

  lastHall = tempHall;
  lastVardagsrum = tempVardagsrum;
        
}

//---------------------------------------------------------------------------------
void timerHitLed()
{
  digitalWrite(5, HIGH);
  delay(100);
  digitalWrite(5, LOW);
}

void setup()
{

  Serial.println("DEBUG: Setup");
  // Debug console
  Serial.begin(9600);

  pinMode(2, OUTPUT); // Relä för level 3
  pinMode(3, OUTPUT); // Relä för level 2
  pinMode(6, OUTPUT); // Relä för level 1
  pinMode(5, OUTPUT); // LED    
  pinMode(4, OUTPUT);
  digitalWrite(4, HIGH);

  Serial.println("DEBUG: Before init");
  Ethernet.init(10); // Pin 10 går till pin 5 på Mkr shield     
  delay(1000);
  Serial.println("DEBUG: After init");
    
  // Vänta lite, öka chansen att routern vaknat efter strömavbrott
  //delay(1000*START_DELAY);
  
  // Authentisera mot cloud
  Serial.println("DEBUG: Before begin");
  Blynk.begin(auth);
  Serial.println("DEBUG: After begin");
  
  // Periodisk funktion, kör varje minut (nästan) för att pusha data
  periodicTimer.setInterval(59000L, timerHit);
  periodicTimer.setInterval(10000L, timerHitLed);
}

void loop()
{
  Blynk.run();
  periodicTimer.run();

}

// Gör om mätvärde till temperatur
double calcTemperature(int reading1, int reading2, int reading3) 
{
  // Medelvärde
  int reading = (reading1+reading2+reading3)/3;
  double Temp;
  Temp = log(10000.0 * ((1024.0 / reading - 1)));
  Temp = 1 /(0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp)) * Temp);
  Temp = Temp - 273.15; // convert from Kelvin to Celsius
  return Temp;
}

void setLevel(byte value)
{
  
// Sätt relä direkt
  if (value==4)
  { 
    digitalWrite(2,LOW);
    digitalWrite(3,LOW);
    digitalWrite(6,LOW);
  }
  if (value==3)
  {
    digitalWrite(2,HIGH);
    digitalWrite(3,LOW);
    digitalWrite(6,LOW);
  }
  if (value==2)
  {
    digitalWrite(2,HIGH);
    digitalWrite(3,HIGH);
    digitalWrite(6,LOW);
  }
  if (value==1)
  {
    digitalWrite(2,HIGH);
    digitalWrite(3,HIGH);
    digitalWrite(6,HIGH);
  }  
}  

So, the MKR ETH shield isn’t designed for use with the Uno, because it has the wrong form-factor.
How are you achieving this hook-up?

Pete.

Hi,
That is true. I am wiring it from pin to pin. I followed this: Arduino MKR eth shield - Project Guidance - Arduino Forum
I left pin 4 unconnected. Back in the days, when starting using Blynk/Arduino, I created the “first time Blynk template” that was autogenerated by Blynk for my setup. I uploaded it and the demo application worked well. Then I built on that and everything was fine. Then I tried the Ethernet shield 2 (correct form factor) and you helped me to get that working. Then it started to malfunction, cannot understand why really, thought there were changes on server side but probably was not. Anyway, I went back to Mkr shield that worked so well, but now it doesn’t.

Few concerns:
1.Connection from Uno to Mkr shield: I think this is ok since it has once worked well.
2.Blynk version, I use 1.1.0 now, I can’t remember what I used back then.
3.Configuration of CS pin for Mkr shield. This is set to 10 in code (it is wired from 10 on Uno to 5 on Mkr shield) but it is not used, maybe used by some included code?

Mkr shield does get an IP address from router and there is clearly some connection with server, even though it is only for a short while. This led me to believe that Ethernet/IP is ok, that Mkr shield is ok.

In code, everything executes and loop is running also, but then, after 25-30 seconds, “Connecting to blynk.cloud:80” comes, and this is repeated.

I wish there were working examples to use, without having to trouble shoot so much :slight_smile:
Arduino Uno with Ethernet shield feels quite standard.

Br Björn

My experience with Ethernet boards have never been good. They can easily stop working for no apparent reason. They can also be very fussy about the type of Ethernet switch that they are attached to.

Is there a reason why you need to use Ethernet rather than WiFi ?

Pete.

Ok, that doesn’t sound promising. Actually, my Arduino application will be placed in a house in the countryside, controlled remotely via Blynk. Since I only have a mobile broadband router there I thought connecting Arduino via Ethernet with cable to the router would be the best alternative. But there is actually no reason why I cannot use Wifi instead. Do you think that would be better?

Thing is, I am worried that I have done some minor mistake with code or libraries. After you helped me to get Ethernet shield 2 to work I used it several days with no issues. Then, suddenly it stopped working. Strange. I wonder if problem is on my side, probably that is the case.

You think that someone from Blynk side can help?

//Björn

Yes.
But I’d also suggest switching to a hardware device that has native WiFi support, rather than trying to add WiFi support to the Uno via an ESP-01 device.
I’d go for a NodeMCU or ESP32 (but not one of the Arduino MKR devices), depending on how many useable pins you need.

I guess it is possible that your ISP is blocking port 80, or blocking the Blynk protocol. You could try switching to an SSL connection, but you’d be far better doing that with different hardware.

Pete.

Ok, Thames. Problem is nodeMCU seems to have only 1 ADC while I need 3 :slightly_frowning_face:.

So use an ESP32, which has 8 ADCs that can be used at the same time as WiFi.

Pete.

Ok, is it more complicated code-wise than programming Arduino? I see that it runs on 3.3V, my electronics are adapted to 5V. A bit unconvinient to redesign that. Just wish Blynk would work via Ethernet instead, but I guess I need to realize that it will not.

//Björn

No, it’s basically the same, and some things, such as WiFi connection are actually easier than an Uno plus ESP-01.

The ESP32 has an onboard 5v to 3.3v regulator, to allow it to be powered via USB.
The pins use 3.3v logic levels, but are 5v tolerant, and most sensors etc are 3.3-5v tolerant too.
If you do have an6 issues then you can use a logic level shifter, but i’ve only ever had one situation where I’ve had to do that.

This topic is about ESP8266 boards, but many of the points raised relate to ESP32s too…

As far as Ethernet boards not working consistently with Blynk, I think it’s more a case of Ethernet boards not working consistently - full stop!

Pete.

Ok, thanks for the link, I might need to restart the project. Just curious why the current solution is not working. I am not sure it’s the shield that is the problem (not saying it isn’t). I added debug and ran with two different values of heartbeat, 45 seconds (default) and 10 seconds. Device connects properly to server. Then it sends a heartbeat at the right time, gets the response in 100-150 ms. This is repeated twice, the third heartbeat signal is not answered by server and timeout will come in a few seconds defined by the blynk timeout set to 3 seconds. Regardless of heartbeat interval it is always the third heartbeat that is not answered. In theory, the third heartbeat signal could always disappear on the way to server but that’s extremely unlikely. Also, reconnection after timeout is always successful, meaning that server is alive and able to send data to device.

When adding a BlynkTimer and pushing data to server it gets even worse, reconnection is triggered after 50 seconds. It seems no heartbeat signals are sent in this situation, probably since the virtual writes are used instead. Before reconnection, this message shows up in debug:
20:23:50.092 → [54633] Sent 5/20
20:23:50.092 → [54656] Connecting to blynk.cloud:80
I don’t know what that is.

@vshymanskyy, do you have any idea what could be the problem?

NOTE: I use Blynk default sketches and quite basic scenarios. I did have my application working but then I think there might have been changes on server side.

Pasted logs below. After the logs, the code for the second case when data is pushed.

23:00:26.557 → BLYNK_HEARTBEAT is: 10
23:00:26.589 → BLYNK_TIMEOUT_MS is: 3000
23:00:26.624 → [1999] Getting IP…
23:00:28.250 → [3697] IP:192.168.0.24
23:00:28.285 → [3698]
23:00:28.285 → ___ __ __
23:00:28.320 → / _ )/ /_ _____ / /__
23:00:28.355 → / _ / / // / _ / '/
23:00:28.390 → /
//_, /////_
23:00:28.390 → /
/ v1.1.0 on Arduino Uno
23:00:28.426 →
23:00:28.426 → #StandWithUkraine https://bit.ly/swua
23:00:28.494 →
23:00:28.494 →
23:00:28.494 → [3863] Connecting to blynk.cloud:80
23:00:28.767 → [4210] <[1D|00|01|00]
23:00:28.800 → [4211] <n1FOQhcYoxKypVJdzpbC3G3nZoT_Mb-T
23:00:28.833 → [4259] >[00|00|01|00|C8]
23:00:28.867 → [4260] Ready (ping: 48ms).
23:00:28.901 → [4269] Free RAM: 924
23:00:28.936 → [4327] <[11|00|02|00|8B]
23:00:28.936 → [4327] <ver[00]1.1.0[00]h-beat[00]10[00]buff-in[00]256[00]dev[00]Arduino Uno[00]cpu[00]ATmega328P[00]con[00]W5100[00]fw-type[00]TMPLixABkY67[00]build[00]Jul 18 2022 23:00:12[00]
23:00:29.140 → [4504] <tmpl[00]TMPLixABkY67[00]
23:00:29.173 → [4579] >[00|00|02|00|C8]
23:00:39.119 → [14540] <[06|00|03|00|00] <<<<<< First heartbeat
23:00:39.256 → [14709] >[00|00|03|00|C8]
23:00:49.117 → [24541] <[06|00|04|00|00] <<<<<< Second heartbeat
23:00:49.254 → [24704] >[00|00|04|00|C8]
23:00:59.125 → [34543] <[06|00|05|00|00] <<<<<< Third heartbeat (no answer)
23:01:02.096 → [37544] <[06|00|06|00|00]
23:01:05.117 → [40545] <[06|00|07|00|00]
//-------------------------------------------------------------------------
23:01:48.676 → BLYNK_HEARTBEAT is: 45
23:01:48.676 → BLYNK_TIMEOUT_MS is: 3000
23:01:48.709 → [1999] Getting IP…
23:01:50.368 → [3697] IP:192.168.0.24
23:01:50.401 → [3698]
23:01:50.401 → ___ __ __
23:01:50.434 → / _ )/ /
_____ / /
_
23:01:50.434 → / _ / / // / _ / '/
23:01:50.470 → /
//_, /////_
23:01:50.503 → /
__/ v1.1.0 on Arduino Uno
23:01:50.537 →
23:01:50.537 → #StandWithUkraine https://bit.ly/swua
23:01:50.604 →
23:01:50.604 →
23:01:50.604 → [3863] Connecting to blynk.cloud:80
23:01:50.942 → [4262] <[1D|00|01|00]
23:01:50.942 → [4263] <n1FOQhcYoxKypVJdzpbC3G3nZoT_Mb-T
23:01:51.010 → [4312] >[00|00|01|00|C8]
23:01:51.010 → [4312] Ready (ping: 48ms).
23:01:51.043 → [4321] Free RAM: 924
23:01:51.077 → [4379] <[11|00|02|00|8B]
23:01:51.112 → [4380] <ver[00]1.1.0[00]h-beat[00]45[00]buff-in[00]256[00]dev[00]Arduino Uno[00]cpu[00]ATmega328P[00]con[00]W5100[00]fw-type[00]TMPLixABkY67[00]build[00]Jul 18 2022 23:01:34[00]
23:01:51.281 → [4556] <tmpl[00]TMPLixABkY67[00]
23:01:51.314 → [4634] >[00|00|02|00|C8]
23:02:36.275 → [49592] <[06|00|03|00|00] <<<<<< First heartbeat
23:02:36.414 → [49755] >[00|00|03|00|C8]
23:03:21.277 → [94593] <[06|00|04|00|00] <<<<<< Second heartbeat
23:03:21.448 → [94772] >[00|00|04|00|C8]
23:04:06.259 → [139594] <[06|00|05|00|00] <<<<<< Third heartbeat
23:04:09.257 → [142595] <[06|00|06|00|00]
23:04:12.270 → [145596] <[06|00|07|00|00]
23:04:15.274 → [148597] <[06|00|08|00|00]
23:04:15.442 → [148774] Heartbeat timeout: 148774, 94773, 148597
23:04:20.288 → [153598] Connecting to blynk.cloud:80
23:04:20.388 → [153729] <[1D|00|01|00]
23:04:20.421 → [153730] <n1FOQhcYoxKypVJdzpbC3G3nZoT_Mb-T
23:04:20.488 → [153778] >[00|00|01|00|C8] <<<<<<< Reconnection successful
23:04:20.521 → [153779] Ready (ping: 45ms).
23:04:20.521 → [153795] Free RAM: 924
23:04:20.555 → [153846] <[11|00|02|00|8B]
23:04:20.590 → [153849] <ver[00]1.1.0[00]h-beat[00]45[00]buff-in[00]256[00]dev[00]Arduino Uno[00]cpu[00]ATmega328P[00]con[00]W5100[00]fw-type[00]TMPLixABkY67[00]build[00]Jul 18 2022 23:01:34[00]
23:04:20.791 → [154037] <tmpl[00]TMPLixABkY67[00]
23:04:20.826 → [154121] >[00|00|02|00|C8]
23:05:05.751 → [199075] <[06|00|03|00|00]
23:05:05.818 → [199131] >[00|00|03|00|C8]
23:05:50.755 → [244077] <[06|00|04|00|00]
23:05:50.958 → [244260] >[00|00|04|00|C8]
23:06:35.769 → [289078] <[06|00|05|00|00]
23:06:38.763 → [292079] <[06|00|06|00|00]
23:06:41.781 → [295080] <[06|00|07|00|00]
23:06:44.774 → [298081] <[06|00|08|00|00]
23:06:44.941 → [298262] Heartbeat timeout: 298262, 244261, 298081
23:06:49.773 → [303082] Connecting to blynk.cloud:80
23:06:49.907 → [303211] <[1D|00|01|00]
23:06:49.940 → [303212] <n1FOQhcYoxKypVJdzpbC3G3nZoT_Mb-T
23:06:49.973 → [303264] >[00|00|01|00|C8]
23:06:50.007 → [303264] Ready (ping: 47ms).
23:06:50.042 → [303278] Free RAM: 924
23:06:50.042 → [303331] <[11|00|02|00|8B]

´´´
Blynk library is licensed under MIT license
This example code is in public domain.

*************************************************************

This example shows how value can be pushed from Arduino to
the Blynk App.

NOTE:
BlynkTimer provides SimpleTimer functionality:
http://playground.arduino.cc/Code/SimpleTimer

App project setup:
Value Display widget attached to Virtual Pin V5
*************************************************************/

/* Comment this out to disable prints and save space */
#define BLYNK_PRINT Serial
#define BLYNK_DEBUG

/* Fill-in your Template ID (only if using Blynk.Cloud) */
#define BLYNK_TEMPLATE_ID           "TMPLixABkY67"
#define BLYNK_DEVICE_NAME           "Quickstart Template"
#define BLYNK_AUTH_TOKEN            "n1FOQhcYoxKypVJdzpbC3G3nZoT_Mb-T"

#include <SPI.h>
#include <Ethernet.h>
#include <BlynkSimpleEthernet.h>

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = BLYNK_AUTH_TOKEN;

BlynkTimer timer;

// Push temperatures to server 
void myTimerEvent()
{
// Measure
Serial.println("Temperatures: ");
double t1 = calcTemperature(analogRead(0));
Serial.println(t1);
double t2 = calcTemperature(analogRead(1));
Serial.println(t2);
double t3 = calcTemperature(analogRead(2));
Serial.println(t3);

// Send temperatures to server
Blynk.virtualWrite(V1,t1);
Blynk.virtualWrite(V2,t2);
Blynk.virtualWrite(V3,t3);
}

// If V0 changed in app
BLYNK_WRITE(V0)
{  
 int currentLevel = param.asInt();
Serial.print("Received value and sent back to server: ");
Serial.println(currentLevel);

Blynk.virtualWrite(V4, currentLevel);
}

// Sync server value
BLYNK_CONNECTED()
{
Blynk.syncVirtual(V0);
}

void setup()
{
// Deselect SD card
pinMode(4, OUTPUT);
digitalWrite(4, HIGH);

// Debug console
Serial.begin(9600);

Ethernet.init(10);

delay(2000);

Blynk.begin(auth);

// Setup a function to be called every tenth second
timer.setInterval(10000L, myTimerEvent);
}

void loop()
{
Blynk.run();
timer.run(); // Initiates BlynkTimer
}

// Value to temperature
double calcTemperature(int reading) 
{
// Medelvärde
//int reading = (reading1+reading2+reading3)/3;
double Temp;
Temp = log(10000.0 * ((1024.0 / reading - 1)));
Temp = 1 /(0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp)) * Temp);
Temp = Temp - 273.15; // convert from Kelvin to Celsius
return Temp;
}
´´´

Log for above program
20:22:57.360 → [1999] Getting IP…
20:22:59.059 → [3689] IP:192.168.0.24
20:22:59.092 → [3690]
20:22:59.092 → ___ __ __
20:22:59.126 → / _ )/ /_ _____ / /__
20:22:59.160 → / _ / / // / _ / '/
20:22:59.195 → /
//_, /////_
20:22:59.195 → /
__/ v1.1.0 on Arduino Uno
20:22:59.228 →
20:22:59.262 → #StandWithUkraine https://bit.ly/swua
20:22:59.296 →
20:22:59.296 →
20:22:59.296 → [3855] Connecting to blynk.cloud:80
20:22:59.567 → [4199] <[1D|00|01|00]
20:22:59.601 → [4200] <n1FOQhcYoxKypVJdzpbC3G3nZoT_Mb-T
20:22:59.634 → [4251] >[00|00|01|00|C8]
20:22:59.668 → [4252] Ready (ping: 51ms).
20:22:59.702 → [4257] Free RAM: 896
20:22:59.735 → [4319] <[11|00|02|00|8B]
20:22:59.735 → [4320] <ver[00]1.1.0[00]h-beat[00]45[00]buff-in[00]256[00]dev[00]Arduino Uno[00]cpu[00]ATmega328P[00]con[00]W5100[00]fw-type[00]TMPLixABkY67[00]build[00]Jul 19 2022 20:22:41[00]
20:22:59.938 → [4494] <tmpl[00]TMPLixABkY67[00]
20:22:59.971 → [4588] >[00|00|02|00|C8]
20:23:00.006 → [4595] <[10|00|03|00|04]
20:23:00.041 → [4595] <vr[00]0
20:23:00.041 → [4652] >[14|00|03|00|06]
20:23:00.075 → [4653] >vw[00]0[00]3
20:23:00.075 → Received value and sent back to server: 3
20:23:00.145 → [4720] <[14|00|03|00|06]
20:23:00.181 → [4722] <vw[00]4[00]3
20:23:09.964 → Temperatures:
20:23:09.999 → 25.80
20:23:09.999 → 24.91
20:23:09.999 → 26.07
20:23:09.999 → [14602] <[14|00|04|00|0F]
20:23:10.032 → [14603] <vw[00]1[00]25.8030700
20:23:10.065 → [14698] <[14|00|05|00|0F]
20:23:10.100 → [14698] <vw[00]2[00]24.9106450
20:23:10.133 → [14766] <[14|00|06|00|0F]
20:23:10.167 → [14766] <vw[00]3[00]26.0718080


20:23:49.991 → Temperatures:
20:23:49.991 → 25.80
20:23:49.991 → 24.91
20:23:50.024 → 26.07
20:23:50.024 → [54602] <[14|00|11|00|0F]
20:23:50.058 → [54603] <vw[00]1[00]25.8030700
20:23:50.092 → [54633] Sent 5/20 <<<<<<< What is this?
20:23:50.092 → [54656] Connecting to blynk.cloud:80
20:23:50.394 → [55003] <[1D|00|01|00]
20:23:50.394 → [55004] <n1FOQhcYoxKypVJdzpbC3G3nZoT_Mb-T
20:23:50.462 → [55057] >[00|00|01|00|C8]
20:23:50.495 → [55057] Ready (ping: 51ms).
20:23:50.495 → [55065] Free RAM: 896
20:23:50.528 → [55124] <[11|00|02|00|8B]
20:23:50.562 → [55126] <ver[00]1.1.0[00]h-beat[00]45[00]buff-in[00]256[00]dev[00]Arduino Uno[00]cpu[00]ATmega328P[00]con[00]W5100[00]fw-type[00]TMPLixABkY67[00]build[00]Jul 19 2022 20:22:41[00]

Hi,
I did some investigation and I cannot see that it is the shield that is the problem, see answer below. I might be wrong but the scenarios below do not indicate communication problems. I tested the very basic scenarios using Blynk and communication between device and Blynk server is extremely unstable.

//Björn

Where?

Pete.

Oh, sorry, it is above this post. Br Björn

Do you think that is this we’re the case for everyone then Blynk would have any customers?

It may be an issue with your ISP, router, Ethernet cable, Ethernet shield or board, or power supply.

Pete.

Hi,
Of course it can be but it is not easy to say from the traces I get. But you’re right, on router connected to fixed IP it works. Does the ISP change my IP address? Yes, for mobile broadband it does and I might need to use DDNS, but it seems a bit strange that the ISP would change IP so often, it is probably something else causing this issue. Wouldn’t such a problem cause total failure?

My application is depending on usage of mobile broadband router.

Br Björn

I didn’t suggest that having a dynamic public IP address was part of the cause, and there is certainly no value in using a DDNS service, as only works in the reverse direction.

Pete.

I know you didn’t. As I understood it, Blynk will initiate communication from device to server, making double NAT problem not applicable. But there seems to be some other problem here. I know that my ISP uses double NAT and that has prevented me from using a web page to control my application.

Br Björn

Double NAT and DDNS are only an issue if you are hosting a server inside your network and trying to access it from outside your network.

The Blynk cloud server is outside your network and you are trying to access it from inside your network, so DDNS and double NAT don’t come into the equation.
You’re looking for problems where none exist, as I said…

Pete.

I know that, but I am trying to understand where the problem is.