OTA or not OTA that is the question...

  • After reading documentation and forum threads and done some trying I am not able to say if WiPy is (will be) able to manage full OTA for firmware update and for user program.
    I am looking for same easy to use OTA functions I found with Particle but without dependencies to internet connection.
    For OTA firmware update it seams to be not possible for now despite the fact that it was documented. I tried without success... Will it be possible one day or not ?
    For OTA user program update it should be necessary to have a hardware reset (cf. If your board is running code at boot time, you might need to boot it in safe mode.). So no really OTA facility.
    Could we have clear answers on these two points as they are main reasons to use or not Py devices.

  • @seb and @robert-hh Thank. @seb I'm waiting for your post.

  • @mdnncl01 From what I understand of your question, you want to update both your application and the firmware. So you have to consider two aspects:

    a) If your application is a Python source file or precompiled file, you can load that, store it into the file system and reboot.

    b) If your application is embedded into the firmware, or if you want to update the firmware, you have to do a firmware update, and that's what is called OTA here. The mechanism itself is implemented and works. Below in the post you see two examples. (i) The first dowloads the new image from a ftp file server and flashes it during the download. That method does not need extra file space on the device. (ii) The second assumes, that the new image is downloaded to the file system and transfers it from the file into the flash. Since the firmware image is pretty large, the internal file system of the old devices cannot handle it. Therefore, in the example a SD card is used. The new pycom devices with 8M flash have sufficient space to store that file and a SD card is not required.

    You migth have to implement your own method of downloading the files or images from your server. The given examples just demonstrate the use of the OTA system calls.

  • The firmware allows the python code to be updated over FTP or UART at the moment and the pycom module include some functions for updating the firmware OTA (https://docs.pycom.io/chapter/firmwareapi/pycom/pycom.html). I am currently working on an example project to demonstrate updating both firmware and python code over WiFi but this will take a couple weeks at least to complete. I will post a reply here once it has been completed.

  • Hi all guys, I'm a beginner in the Pycom and Python world. With my team we decided to start experimenting with these devices (WiPy),
    but for us it is absolutely essential to update the OTA of the user application for a real use in the field. From all the discussions
    and documentation this aspect is not very clear; It would also be nice to have a possible firmware upgrade of the module; this aspect
    is also unclear. Is there currently a stable procedure to update at least the user application? I'm sorry for my english. Thanks

  • @robert-hh
    I'm also trying. Occasionally I have memory allocation problems, nothing that can't be solved with the garbage collector.
    Thanks for the tips

  • @paco88 Of course, several times. And I verified that the new image is then excuted, by embedding changing frozen bytecode.
    The example below is simplified, in that I had to insert a gc.collect() into the do_write() function, epsecially with a larger buffer size.
    I have sketched another example here, which uses a fixed preallocated buffer. And yes, I tested that variant too.

    # Firmware update by reading the image from the SD card
    from pycom import ota_start, ota_write, ota_finish
    from os import mount
    from machine import SD
    BLOCKSIZE = const(4096)
    APPIMG = "/sd/appimg.bin"
    sd = SD()
    mount(sd, '/sd')
    with open(APPIMG, "rb") as f:
        buffer = bytearray(BLOCKSIZE)
        mv = memoryview(buffer)
        while True:
            chunk = f.readinto(buffer)
            if chunk > 0:
                size += chunk
                print("\r%7d " % size, end="")

  • @robert-hh
    Have you performed a full OTA write?

  • @betterauto You do not have to store the file in the local files system, if there is no space. You can feed the data into OTA on the fly while fetching.
    I made a few attempts with:

    • interrupting an update and then starting a new one.
    • repeating the update w/o restart in between.

    All was stable. Not a very exhaustive test, but at least a first check. Since the image itself carries a checksum & signature, which is checked at the call of ota_finish(), transmission errors should not harm.

  • Pybytes Beta

    So this code uploads a bin file from the local file system to the local ftp server? Looks like the other way round.

    Edit: Nevermind, I see you are fetching the file from an ftp server to flash it. Beautiful. I can do the same but fetch the file with MQTT over TLS to the local file system and flash itself in chunks.

    I hope to try it soon. Nice find.

  • @betterauto OK. So here is my very simple sample script, using ftplib:

    # OTA update using ftplib and the pycom.ota_* methods
    from ftplib import *
    from pycom import *
    def do_write(data):
        print(".", end="")
    def ota():
        ftp = FTP("server_ip", 21, "user", "password")
        ftp.retrbinary("RETR appimg.bin", do_write, 1024)

    I added an intermediate call to do_write() to have an progress indication.
    Obviously you can use ftplib to download other files as well.

  • @betterauto It ONLY updates the firmware. There is no documentation yet. I'll give it a try by using ftplib for downloading the file and let you know.

  • Pybytes Beta

    @robert-hh does that only update files or also the firmware? Where do I find more info on this?

  • @robert-hh By looking into the pycom module I found that an OTA interface for Python scripts already exists. There are three methods:
    So one can easily use them. Start the update by calling ota_start(). Then receive the image data in arbitrary chunks and call ota_write() with it. Once the data is transferred, call ota_finish().

  • This post is deleted!

  • Pybytes Beta

    What error did you get? Doesn't make sense it can't connect to itself, it's just another IP right?

  • @betterauto Actually I gave it a try. The ftp client is working, when I connect to a different device. But I could not get a connection to itself.
    Unless there is another option, you could do that: If you have a cluster of devices, then one of them could act as an update server, which pulls the update from a remote hub and distributes that locally.

  • @BetterAuto If you can have a ftp client connect to the local server, then it should be possible. A small ftp client was provided by spotlightkid here: https://github.com/SpotlightKid/micropython-ftplib

  • Pybytes Beta

    I had envisioned the devices self-updating by downloading the file to the local file system via a secure manner e.g. HTTPS or MQTT over TLS then copying that via an FTP client Py script to its own internal FTP server for final install. If you're saying the internal file system is too small I could see using the SD card or perhaps even an external I2C flash memory.

    Is this feasible?

  • @Paco88 Sorry Sir. Please explain more detailed what you want to achieve and what you tried to get here.
    The FAT file system of a standard WiPy is too small to hold the file appimg.bin. If you want to store appimg.bin in the file system, you have to extend it, e.g. by adding a SD card. And still, at the moment you cannot install that file as a new firmware. One could try to implement a similar mechanism as is used for OTA: if an attempt is made to store a file at /flash/sys, it is accepted as a new firmware stream. But that is not there yet and tricky to implement.

Log in to reply

Pycom on Twitter