Arduino Mega+WiFi - OTA via Blynk with WiFiEspAT.h possible?

[tamibandy]

Hi Juraj,

I have some Mega+WiFi boards and I started to do some projects with them.
Right now I have an Optiboot bootloader on ATmega2560 chip, AT v1.7.4 firmware on the ESP8266 chip. The communication between the ATmega2560 and ESP8266 is on Serial3. I used your WiFiEspAT.h library for this.
The project is connected to the Blynk. ArduinoOTA is implemented (used your library again :D), and is working. I can download new code via fake Programmer solution.

But thinking for the next step, to be easier to download new code for board, I want to use the Blynk OTA feature.

It is possible to use Blynk OTA for ATmega2560 via ESP8266 (with AT firmware)?

UPDATE(17.11.2023)
The Blynk OTA is working with InternalStorage from ArduinoOTA library by @JAndrassy. See code part below
After this I managed to add a webserver to the sketch, and a possibility to upload new sketch via web browser. Using the InternalStorage again. See code part below.

Code part for Blynk OTA:

// Blynk OTA update
BLYNK_WRITE(InternalPinOTA) {
  // Close the webserver connection, not to interfere with OTA process
  webServer.end();
  
  String overTheAirURL = "";
  overTheAirURL = param.asString();

  Blynk.logEvent("sys_ota", "OTA started");

  // Disconnect, not to interfere with OTA process
  Blynk.disconnect();

  const unsigned short SERVER_PORT = 80;    // Commonly 80 (HTTP) | 443 (HTTPS)
  WiFiClient wifiClient;

  String host, url;
  int index = overTheAirURL.indexOf(':');
  if(index < 0) {
    return;
  }
  overTheAirURL.remove(0, index + 3); // remove protocol part
  index = overTheAirURL.indexOf('/');
  host = overTheAirURL.substring(0,index);
  overTheAirURL.remove(0, index); // remove host
  url = overTheAirURL;
  Serial.print(F("Check for update file "));
  Serial.print(F("http://"));
  Serial.print(host);
  Serial.println(url);
  HttpClient client(wifiClient, host, SERVER_PORT);
  client.get(url);

  int statusCode = client.responseStatusCode();
  Serial.print(F("Update status code: "));
  Serial.println(statusCode);
  if (statusCode != 200) {
    client.stop();
    return;
  }

  long length = client.contentLength();   // Need to modify the contentLength() and iContentLength datatype from int to long in HttpClient.h and HttpClient.cpp
  if (length == HttpClient::kNoContentLengthHeader) {
    client.stop();
    Serial.println(F("Server didn't provide Content-length header. Can't continue with update."));
    return;
  }
  Serial.print(F("Server returned update file of size "));
  Serial.print(length);
  Serial.println(" bytes");

  if (!InternalStorage.open(length)) {
    client.stop();
    Serial.println(F("There is not enough space to store the update. Can't continue with update."));
    return;
  }
  byte b;
  while (length > 0) {
    if (!client.readBytes(&b, 1)) // reading a byte with timeout
      break;
    InternalStorage.write(b);
    length--;
  }
  InternalStorage.close();
  client.stop();
  if (length > 0) {
    Serial.print(F("Timeout downloading update file at "));
    Serial.print(length);
    Serial.println(F(" bytes. Can't continue with update."));
    return;
  }

  Serial.println(F("Sketch update apply and reset."));
  Serial.flush();
  InternalStorage.apply(); // this doesn't return
}

Code part for WebServer OTA:

else if ((line.length() == 0 && contentLength > 0)) {                                                                       //
  line = client.readStringUntil('\n');                                                                                      // ------WebKitFormBoundaryOEiRC60n5oNkEHxt
  line.trim();                                                                                                              //
  contentLength = contentLength - 2 * line.length() - 6;                                                                    // Remove two times the this line from length, because is the first and the last line are nearly same.
                                                                                                                            // The last line have 2 characters more and every new line has CR+LF characters for new line
                                                                                                                            // 
  line = client.readStringUntil('\n');                                                                                      // Content-Disposition: form-data; name="update"; filename="Empty.ino.bin"
  line.trim();                                                                                                              //
  contentLength = contentLength - line.length() - 2;                                                                        // Remove the length of the next line and the CR+LF
  line = client.readStringUntil('\n');                                                                                      // Content-Type: application/octet-stream
  line.trim();                                                                                                              //
  contentLength = contentLength - line.length() - 6;                                                                        // Remove the length of the next line and the CR+LF
                                                                                                                            // and additionally removing the CR+LF for the empty row and for the file row.
  line = client.readStringUntil('\n');                                                                                      // <empty row>
                                                                                                                            // After this lines the pointer of the HTTP message is on the *.bin file starting byte
  Serial.print(F("Uploading new firmware with size of "));                                                                  //
  Serial.print(contentLength);                                                                                              // This contentLength need to match with the *.bin file size
  Serial.println(F(" bytes"));                                                                                              //
                                                                                                                            //
  // Disconnect, not to interfere with OTA process                                                                          //
  Blynk.disconnect();                                                                                                       //
                                                                                                                            //
  if (!InternalStorage.open(contentLength)) {                                                                               //
    client.stop();                                                                                                          //
    Serial.println(F("There is not enough space to store the update. Can't continue with update."));                        //
    return;                                                                                                                 //
  }                                                                                                                         //
                                                                                                                            //
  byte b;                                                                                                                   //
  while (contentLength > 0) {                                                                                               //
    if (!client.readBytes(&b, 1)) // reading a byte with timeout                                                            //
      break;                                                                                                                //
    InternalStorage.write(b);                                                                                               //
    contentLength--;                                                                                                        //
  }                                                                                                                         //
  InternalStorage.close();                                                                                                  //
  client.stop();                                                                                                            //
  if (contentLength > 0) {                                                                                                  //
    Serial.print(F("Timeout downloading update file at "));                                                                 //
    Serial.print(contentLength);                                                                                            //
    Serial.println(F(" bytes. Can't continue with update."));                                                               //
    return;                                                                                                                 //
  }                                                                                                                         //
                                                                                                                            //
  Serial.println(F("Sketch update apply and reset."));                                                                      //
  Serial.flush();                                                                                                           //
  InternalStorage.apply(); // this doesn't return                                                                           //
                                                                                                                            //
  break;                                                                                                                    //
}

Thanks,
Regards,
Andras

[JAndrassy]

yes. even BlynkEdgent framework uses this library. but BlynkEdgent doesn't support Arduino Mega.
on Blynk forum, there is a post with basic Blynk OTA download. you can adapt it to download the update binary into InternalStorage as the advanced examples of ArduionOTA show

[tamibandy]

I searched for that basic Blynk OTA download post in community, but I didn't find any useful thing for my problem.

Can you give me some more hints what should I search for, from which direction I need to attack the problem?

Thanks

[JAndrassy]

https://community.blynk.cc/t/blynk-air-ota-minimal-code/58929

[tamibandy]

@JAndrassy
Hello again, right now is working the firmware update via Blynk(with this two libraries: ArduinoOTA.h and ArduinoHttpClient.h).
I made a webserver too for the arduino, and my question: is it possible somehow to upload a sketch via webserver to arduino in this configuration?

[tamibandy]

Yes I though that can be the problem that the OTA doesn't works anymore.
I know that I can set my home router, but this arduinos are going to customers and there are not so easy to set their routers and the customer wants to have webserver to be able to verify some of the data on intranet.

So because of that I'm trying to make it work with webserver. To be easy for me the commissioning.

Yes, I'm working with that part of code what you have linked. Progressing but not functional yet. I uploaded the *.bin file but looks like the arduino doesn't work with that.

Thanks for the tip

[tamibandy]

I made a test, write to serial monitor the file size:
Uploading with Blynk the file size is 59512 byte
Uploading with Webserver the file size is 59720 byte(Content-Length)

If I open the properties of the *.bin file, the file size is 59512

So, what could be the problem? From where is coming this 208 byte difference? Why is bigger the *.bin file if is uploaded by webserver?

[tamibandy]

So I found from where comes the 208 byte difference.
The form is enctype='multipart/form-data' type and in the HTTP content sends with boundaries.

Right now with my current configuration(see in my earlier post) I'm able to use the Blynk OTA and the webserver OTA methods to download the sketch to the arduino.

It was a good challenge, I learned a lot.

[JAndrassy]

could you reduce it to an example?

[luca-stm32]

Hi tamibandy, hi JAndrassy
I tried to implement a WebServerOTA with ENC28J60, STM32 and ArduinoOTALibrary too (see [https://github.com//discussions/185])
Finally I successfully realized a functional code:
Test_OTA_Server.zip

My example verify also if the end boundary in POST response is ok.
Maybe it could be optimized: I'm not a very good programmer.

Regards.
Luca