firmware update by code

[avizipi]

Was looking around for the best practice for a single connected camera firmware update by code.

In my scenario I have one camera connected and I would like to check if the firmware on that camera is a specific one. if not to update it.
Reading these issues and code examples:
https://github.com/IntelRealSense/librealsense/blob/master/tools/fw-update/rs-fw-update.cpp
#7095
#4416
https://github.com/IntelRealSense/librealsense/blob/master/include/librealsense2/h/rs_device.h

I noticed several things.

• recovery mode and non-recovery mode firmware updates are the same (code-wise). In both the tools calls rs2_update_firmware_unsigned_cpp() function.
• updatable() and update_device() modes will reset the device and check if the device can be updated, but only in update_device() you can actually update the device.

Will love it if someone can confirm all of these.

Another open issue from my side is what is the difference between the rs2_update_firmware_unsigned_cpp() and rs2_update_firmware_cpp() functions (in the last link), it seems that in the high level code only rs2_update_firmware_unsigned_cpp is used by calling update_device.update()

Code examples for other users.

python: (tested on python 3.8 and pyrealsense2 2.53.1)

import pyrealsense2 as rs
fw_file = "Signed_Image_UVC_5_12_6_0.bin"
ctx = rs.context()
dev = ctx.query_devices()[0]
with open(fw_file, "rb") as fw:
    dev.as_update_device().update(list(fw.read()))

cpp: (tested on sdk 2.39.0)

std::vector<uint8_t> D415CameraDriver::getFwImage(std::string& file_path)
{
std::ifstream file(file_path, std::ios::in | std::ios::binary | std::ios::ate);
    if (file.is_open())
    {
        fw_image.resize(file.tellg());
        file.seekg(0, std::ios::beg);
        file.read((char*)fw_image.data(), fw_image.size());
        file.close();    
    }    
return fw_image;
}
void D415CameraDriver::updateFirmware(rs2::device device, std::vector<uint8_t> fw_image)
{
    std::condition_variable cv_wait_for_updatable_device;
    rs2::update_device update_device;
    std::mutex mutex;
    std::string update_serial_number = device.get_info(RS2_CAMERA_INFO_FIRMWARE_UPDATE_ID);
    ctx.set_devices_changed_callback([&](rs2::event_information& info)
    {
        if (info.get_new_devices().size() == 0)
        {
            return;
        }

        for (auto&& d : info.get_new_devices())
        {

            if (d.get_info(RS2_CAMERA_INFO_FIRMWARE_UPDATE_ID) != update_serial_number)  // do not use here serial number
            {
                continue;
            }
            std::lock_guard<std::mutex> lk(mutex);
            if (d.is<rs2::update_device>())
            {
                update_device = d;
                break;
            }
        }
        if (update_device)
        {
            cv_wait_for_updatable_device.notify_all();
        }
    });

    auto upd = device.as<rs2::updatable>();
    upd.enter_update_state();
    std::unique_lock<std::mutex> u_lk(mutex);
    if (!cv_wait_for_updatable_device.wait_for(u_lk, std::chrono::seconds(10), [&] { return update_device; }))
    {
        std::cout << "Failed to locate a device in FW update mode" << std::endl;
        break;
    }

    update_device.update(fw_image, 
               [&](const float progress)
                {
                    printf("Firmware update progress: %d[%%]", (int)(progress * 100));
                }
                );

    std::cout << std::endl << std::endl << "Firmware update done" << std::endl;
}

void main()
{
std::string file_path = "Signed_Image_UVC_5_12_6_0.bin";
std::vector<uint8_t> fw_image = getFwImage(file_path);
if (fw_image.size()) 
{
updateFirmware(dev, fw_image);
}
else
{
    std::cout << std::endl << std::endl << "Didn't found an image" << std::endl;
}
}

[MartyG-RealSense]

Hi @avizipi You are correct about the similarity of the code for recovery and non-recovery firmware updates when examining rs-fw-update.cpp, as discussed at #11364 (comment)

At #4416 (comment) a RealSense team member confirms that the procedure is to (1) set the camera as updatable, (2) call enter_update_state and then finally (3) update the camera, which can be done with as_update_device

I note though that you had problems at #4416 (comment) with scripts that use that procedure.

An unsigned firmware is one that is a backup of a firmware but cannot be used to firmware-update a camera, as discussed at #7093 (comment)

Official documentation about rs2_update_firmware_unsigned_cpp() can be found at the link below.

https://intelrealsense.github.io/librealsense/doxygen/rs__device_8h.html#a8cd01ad94180743706d6f1ae138d67e8

Its reference to rs2_update_firmware_unsigned_cpp() only working on an unlocked camera indicates to me that it is a function designed for use internally by Intel RealSense engineers with cameras that have access to advanced test and debug functions rather than by 'locked' retail cameras owned by end-users.

If you scroll up the page slightly at the above documentation link then you will find the documentation for rs2_update_firmware_cpp()

[avizipi]

Thanks!

I will update the cpp code when I finish testing it

[galikrosentalik]

I have a problem with the cpp code, it seems that the udp returns NULL

    auto devs = ctx.query_devices(RS2_PRODUCT_LINE_DEPTH);
    for(auto&& device : devs)
    {
            try
            {
                auto upd = device.as<rs2::update_device>();
                upd.update(fw_image,
                           [&](const float progress)
                           {
                                    printf("Firmware update progress: %d[%%]", (int)(progress * 100));
                           }
                );
            }
            catch(rs2::error _err)
            {
                    printf("ERROR- %s, FUNC- %s, ARGS- %s", _err.what(), _err.get_failed_function().c_str(), _err.get_failed_args().c_str());
            }
    }

I am getting:
ERROR- null pointer passed for argument "device", FUNC- rs2_update_firmware_cpp, ARGS- device:nullptr, fw_image:0x7f0f8436e010

[MartyG-RealSense]

Hi @galikrosentalik Typically, the term dev is used in the 'for(auto&&' instruction instead of 'device'. For example:

for(auto&& dev : ctx.query_devices(RS2_PRODUCT_LINE_DEPTH));

[galikrosentalik]

sorry, but I didn't understand the context of your post. Is it relevant to this specific error?

[MartyG-RealSense]

The part of the error messsage null pointer passed for argument "device" suggests that the problem may be related to your use of 'device' instead of 'dev' in for(auto&& device : devs) - though some people do use 'device too - so it may be worth trying to change device to dev to see whether it makes a difference.

Also, try for(auto&& dev : ctx.query_devices(RS2_PRODUCT_LINE_DEPTH)); instead of substituting in ctx_query_devices with 'devs'.

[avizipi]

Hi @MartyG-RealSense,
After a few attempts I still can't update the firmware in CPP.
The code I wrote do not work. I also getting the same error as @galikrosentalik.
it seems that the line:
auto upd = device.as<rs2::update_device>();
restart the device and we need to reconnect to it. (@MartyG-RealSense can you verify this?)

following the code in realsense repo I now trying to use something like this:

rs2::context ctx;
sleep(1);
auto devs = ctx.query_devices(RS2_PRODUCT_LINE_DEPTH);
for(auto&& device : devs)
    {
        if (device.get_info(RS2_CAMERA_INFO_SERIAL_NUMBER) != serialNumber)
        {
            continue;
        }
        std::condition_variable cv_wait_for_updatable_device;
        rs2::update_device update_device;
        std::mutex mutex;
        ctx.set_devices_changed_callback([&](rs2::event_information& info)
        {
            if (info.get_new_devices().size() == 0)
            {
                return;
            }
            for (auto&& d : info.get_new_devices())
            {
                if (d.get_info(RS2_CAMERA_INFO_SERIAL_NUMBER) != serialNumber)
                {
                    continue;
                }
                std::lock_guard<std::mutex> lk(mutex);
                if (d.is<rs2::update_device>())
                {
                    update_device = d;
                    break;
                }
            }
            if (update_device)
            {
            cv_wait_for_updatable_device.notify_all();
            }
        });
        auto upd = device.as<rs2::updatable>();
        upd.enter_update_state();
        std::unique_lock<std::mutex> u_lk(mutex);
        if (!cv_wait_for_updatable_device.wait_for(u_lk, std::chrono::seconds(15), [&] { return update_device; }))
        {
            std::cout << "Failed to locate a device in FW update mode" << std::endl;
            continue;
        }
        std::lock_guard<std::mutex> lk_g(mutex);
        update_device.update(fw_image, [&](const float progress) {std::cout << "Firmware update progress" << std::endl;});
        std::cout << " Firmware update done" << std::endl;
        break;
    }

But It seems that the condition variable is never triggered, and I miss something with the set_devices_changed_callback.

EDIT:

it seems that the line if (d.get_info(RS2_CAMERA_INFO_SERIAL_NUMBER) != serialNumber) is the cause of the problem.
when I get a device by listing all devices from rs2::event_information::get_new_devices I am getting different serial numbers compare to listing all devices from rs2::context::query_devices.

I tested this with one camera connected and the serial number didn't match...

[MartyG-RealSense]

I could only find one other example - at #931 - where rs2::event_information::get_new_devices has previously been used and that was in December 2017, back when the RealSense 400 Series cameras were first launched.

ctx.query_devices is the usual way in which a list of all attached cameras and their serial numbers is automatically generated, like in the RealSense SDK's multiple camera example program rs-multicam.

https://github.com/IntelRealSense/librealsense/blob/master/examples/multicam/rs-multicam.cpp#L23-L24

[avizipi]

It is also used in the fw update example.

It seems that you can not read the serial number from a rs2::device got from rs2::event_information::get_new_devices. I think it should be mark as a BUG.
Anyhow I found a work around and updated the cpp code in my original question for others to use.

[MartyG-RealSense]

Thanks very much for sharing your experience and solution with the RealSense community :)