Issue flashing firmware to ESP32-S3

[dfgHiatus]

Hello, I am attempting to write a merged firmware file using your tool to an ESP32-S3 I own. I have attached the code I am using to accomplish this, it is based off of the sample code:

public class FirmwareService
{
    public event Action OnFirmwareUpdateStart;
    public event Action<float> OnFirmwareUpdateProgress;
    public event Action OnFirmwareUpdateComplete;


    public async Task UploadFirmwareAsync(string port, string pathToFirmware, CancellationToken token = default)
    {
        var toolbox = new ESPToolbox();
        var communicator = toolbox.CreateCommunicator();
        toolbox.OpenSerial(communicator, port,  115200);

        var loader = await toolbox.StartBootloaderAsync(communicator);
        var chipType = await toolbox.DetectChipTypeAsync(loader);

        var softloader = await toolbox.StartSoftloaderAsync(communicator, loader, chipType);
        await toolbox.ChangeBaudAsync(communicator, softloader, 921600);

        var uploadTool = toolbox.CreateUploadFlashDeflatedTool(softloader, chipType);
        var myFirmware = GetFirmware(pathToFirmware);
        var progress = new Progress<float>(p => OnFirmwareUpdateProgress?.Invoke(p));

        OnFirmwareUpdateStart?.Invoke();
        await toolbox.UploadFirmwareAsync(uploadTool, myFirmware, token, progress);
        await toolbox.ResetDeviceAsync(communicator);
        OnFirmwareUpdateComplete?.Invoke();
    }

    private IFirmwareProvider GetFirmware(string pathToFirmware) // this is the local path of the merged-firmware.bin file
    {
        return new FirmwareProvider(
            entryPoint: 0x00000000,
            segments:
            [
                new FirmwareSegmentProvider(0x00000000, File.ReadAllBytes(pathToFirmware)),
            ]
        );
    }
}

Interestingly, while I am able to write to the device, and the device shows up in the device manager, it does not function as intended. I am trying to use this to make the device act as a serial camera for Project Babble. I am able to use the EyeTrackVR Firmware Flashing Tool here to flash the device, if it is any context.

To reproduce:

1. Create a new console project, and insert the above code/firmware attached in question
2. Wait for the firmware to flash
3. Download Project Babble. Attempt to open the serial camera as input, observe nothing happens
4. Download the ETVR Firmware Flashing app and flash Babble_USB-wrooms-s3-v2.9.1-main to your device
5. Repeat step 3, observe the device tracker works

After speaking with an ETVR dev, I cam confirm this is how their app works for the merged Babble firmware (device offsets of 0 when flashing)

I have also attached the merged firmware file in question. This is the Babble_USB-wrooms-s3-v2.9.1-main firmware, you can find a copy of it in the releases for OpenIris.

• manifest.json
• merged-firmware.zip

I have also attached a device log. It appears to be bootlooping here?

• esp-web-tools-logs.txt

Let me know if you have any questions! I would be happy to clarify things

[dfgHiatus]

I will attach a reproduction binary for this in a sec...

[dfgHiatus]

net8.0.zip

using EspDotNet;
using EspDotNet.Tools.Firmware;

namespace DemoApp;

class Program
{
    private static async Task UploadFirmwareAsync(string port, CancellationToken token = default)
    {
        var toolbox = new ESPToolbox();
        var communicator = toolbox.CreateCommunicator();
        toolbox.OpenSerial(communicator, port,  115200);

        var loader = await toolbox.StartBootloaderAsync(communicator);
        var chipType = await toolbox.DetectChipTypeAsync(loader);

        var softloader = await toolbox.StartSoftloaderAsync(communicator, loader, chipType);
        await toolbox.ChangeBaudAsync(communicator, softloader, 921600);
        var progress = new Progress<float>(p => Console.WriteLine($"Progress: {p * 100:F2}%"));

        var uploadTool = toolbox.CreateUploadFlashDeflatedTool(softloader, chipType);
        var myFirmware = GetFirmware();

        await toolbox.UploadFirmwareAsync(uploadTool, myFirmware, token, progress);
        await toolbox.ResetDeviceAsync(communicator);
    }

    private static IFirmwareProvider GetFirmware() // this is the local path of the merged-firmware.bin file
    {
        return new FirmwareProvider(
            entryPoint: 0x00000000,
            segments:
            [
                new FirmwareSegmentProvider(0x00000000, File.ReadAllBytes("merged-firmware.bin")),
            ]
        );
    }

    async static Task Main(string[] args)
    {
        Console.WriteLine("Please input a port number.");
        var port = Console.ReadLine();
        await UploadFirmwareAsync(port);
    }
}

[vanBassum]

Thanks for the detailed report and reproduction steps.

To better determine whether the issue originates from my tool or elsewhere, could you try flashing the same merged-firmware.bin file using the official esptool.py or Espressif’s Flash Download Tool? If the firmware still fails to work as expected, that would suggest the issue lies with the firmware image or hardware setup rather than my tool.

Unfortunately, I don’t have an ESP32-S3 myself, so I’m unable to reproduce or directly test this scenario. If it does work using the official tools, I’d have to dig deeper to figure out what might be going wrong in my implementation.

[dfgHiatus]

Hello there! I experimented with two tools, esptool.py and espflash. I was able to flash my firmware using the following commands:

• python3 -m esptool --chip esp32-s3 --port COMX --baud 921600 write_flash 0x0 "merged-firmware.bin"
• espflash write-bin 0x00 "merged-firmware.bin" --port COMX --baud 921600

Let me know if there is anything else I can test for you!

[vanBassum]

Thank you, that would suggest the issue is in the tool. I'd have to look into this further, perhaps I can try to reproduce this issue on an ESP32 with other firmware. I would love to solve this issue, however, I'm not sure when I get around to doing this.

My first step would be to check what is actually written to the flash and compare this to the source file. Perhaps you can help me with this?

EDIT: Also, have you tried to flash the bin file without compression?

[dfgHiatus]

I haven't altered any settings that would influence compression, but I'll be on the lookout if anything like that pops up.

And sure, what can I do for you here?

[vanBassum]

I was asking if you can read the contents of the ESP flash chip and compare them to the binary file. If there are differences, something goes wrong while uploading. If we know where the differences are, perhaps this points towards a solution.

In the meantime, you can try to upload the firmware without compression using this example:

var toolbox = new ESPToolbox();
var communicator = toolbox.CreateCommunicator();
toolbox.OpenSerial(communicator, port,  115200);

var loader = await toolbox.StartBootloaderAsync(communicator);
var chipType = await toolbox.DetectChipTypeAsync(loader);

var softloader = await toolbox.StartSoftloaderAsync(communicator, loader, chipType);
await toolbox.ChangeBaudAsync(communicator, softloader, 921600);
var progress = new Progress<float>(p => Console.WriteLine($"Progress: {p * 100:F2}%"));

// Here, instead of the CreateUploadFlashDeflatedTool we use the CreateUploadFlashTool
var uploadTool = toolbox.CreateUploadFlashTool(softloader, chipType);
var myFirmware = GetFirmware();

await toolbox.UploadFirmwareAsync(uploadTool, myFirmware, token, progress);
await toolbox.ResetDeviceAsync(communicator);

[dfgHiatus]

Hey there! Sorry for the delay on things. I'm running this on Linux, but the line var communicator = toolbox.CreateCommunicator(); seems to hang for me. I'll try this out on Windows and get back to you.