How launching freetribe over sysex should work

[lysergik]

Hello everyone !

I've discovered recently that beyond the Hacktribe there was this project. I've been interested for a while by audio programmation, groovebox and custom firmware stuff. So I would like to test to code some programs for Freetribe. Since I'm not into soldering stuff to my electribe I would like to run stuff through the sysex transfer. So I follow the documentation I could find to do so, I did upgrade my hacktribe to the last on I could find on github, I downloaded freetribe repo and used docker to build the demo. Then using the execute_freetribe.py and my usb/midi interface got the bin file to start the transfer. The screen of the electribe turns a kind of yellow and the terminal says it starts the transfer. However it doesn't seems to end nothing is happening on the electribe or the terminal after a while. Is there somehing I'm missing ? I'll paste the output I got from the script :

INFO:root:Load and execute Freetribe. INFO:root:Initialising MIDI connection. DEBUG:root:Initialise SysEx 1 Midi Through:Midi Through Port-0 14:0 2 CH345:CH345 MIDI 1 24:0 Please enter your selection number: 2 INFO:root:Input port selected: CH345:CH345 MIDI 1 24:0 1 Midi Through:Midi Through Port-0 14:0 2 CH345:CH345 MIDI 1 24:0 Please enter your selection number: 2 INFO:root:Output port selected: CH345:CH345 MIDI 1 24:0 INFO:root:Found device. INFO:root:Global channel: 0 INFO:root:Pivoting to Freetribe loader. INFO:root:Sending magic word. DEBUG:root:Sending message: F0 42 30 00 01 24 64 01 23 45 67 F7 DEBUG:root:Received message: F0 42 30 01 24 76 54 32 10 F7 INFO:root:Loading binary... INFO:root:Loading chunk: 0 of 95 DEBUG:root:Called load_cpu_ram DEBUG:root:Sending data
I've set midi clock to external on the electribe, global midi channel is 01, no midi filter in or out. Both midi cable are pluged in the electribe.

If anyone as some experience with it I would be glad to have a bit of help with that !

[vanana-old-acc]

Hi!🕷

I think that your electribe MIDI settings are already fine, you already have a properly established sysex connection. My first thought is: which binary are you trying to run?

[lysergik]

I tried the demo app and monosynth app. Those you find on the main branch of freetribe repo.

[vanana-old-acc]

assuming you have latest hacktribe patch installed, a build of it should work. have you tried this one from enormann
i just tried it for myself and that one works

[lysergik]

Well, I just tested it out and I've got the same exact behaviour. If I eventually installed a version of the hacktribe that doesn't support that feature would it still have the screen going yellow using the script to launch freetribe ? It seems odd to me since I pulled hacktribe from the last dev branch commit yesterday... Maybe I should compile the application using dev branch for the freetribe repo ?

[vanana-old-acc]

Older versions might still have working sysex boot, but it was worth mentioning just in case.
What should happen is that the screen sequentially turns teal, magenta, and yellow, not just stuck at yellow.
Since your log cuts off at DEBUG:root:Called load_cpu_ram DEBUG:root:Sending data , is that where it gets stuck?

[lysergik]

Yes that is that, it's stuck at : DEBUG:root:Sending data

[vanana-old-acc]

So in e2sysex.py, in write_cpu_ram()

        logging.debug("Sending data")
        self.outport.send(msg)

        response = self.sysex_response()
        logging.debug("Sysex response: " + str([hex(r) for r in response]))

can you check whether it gets stuck sending in self.outport.send(msg)?
I suggest changing the mido MIDI backend to portMIDI if it was previously RtMidi and vice-versa.

if it hangs waiting for a response in response = sysex_response() then you may also try to use other programs to test the sysex message sequence manually.

[lysergik]

Hi ! Thanks for that ! I saw that chunk size was a reported issue but I didn't knew that would be the symptom for it. I added a print state and saw that package was sent but never got the ACK from the electribe.

Then, since I often feel frustrated by python, it's dependencies, venv ect... I eventually made a few messages to a famous LLM to have a C++ clone of python script but now with a scalable chunk size. Turns out that 56 byte is a sweetspot for my cheap usb interface, anything higher than that was not transmitted properly.

I'll share bellow the code I got from the LLM. I know it can be sometimes a sensitive subject, so if people get mad at me I'll remove it. However, it's 500 lines long, has a simple and effective ncurses interface, doesn't require getting forks of libraries or having to mess around with python packaging and virtual environment, isn't two scripts combined together(so stopping to work if you move it from a folder to another). The core feature is that you can set the chunk size you use, and I think it will help people who will land on that thread with the exact same issue. Well once again if it violates some ethical boundaries within the community I'll edit out the code bellow. If some more competent people sysex/midi wise want to take that code and make sure it's a fine piece of code they are welcome to do so :

/* 
Made for to compile and run on linux. Compiled and tested on Debian 13.
Compile with : g++ -std=c++17 -o freetribe_loader freetribe_loader.cpp -I/usr/include/rtmidi -lrtmidi -lncurses -lpthread
(Note that flags for Rtmidi can change depending of your distro, it's very easy to fix if g++ cannot find it even though you installed the package)
Requires : librtmidi-dev libncurses-dev g++ pkg-config
You can run a binary by executing : ./freetribe_loader path/to/your/cpu.bin
For more info about arguements and examples execute ./freetribe_loader --help
*/

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
#include <cstring>
#include <stdexcept>
#include <chrono>
#include <thread>
#include <filesystem>
#include <ncurses.h>
#include <RtMidi.h>

namespace fs = std::filesystem;

// ---------------------------------------------------------------------------
// Config
// ---------------------------------------------------------------------------

struct Config {
    int    chunk_size = 56;
    std::string in_port;
    std::string out_port;
};

fs::path config_path() {
    const char* home = getenv("HOME");
    return fs::path(home ? home : ".") / ".config" / "freetribe_loader.conf";
}

Config load_config() {
    Config cfg;
    std::ifstream f(config_path());
    if (!f) return cfg;
    std::string line;
    while (std::getline(f, line)) {
        auto eq = line.find('=');
        if (eq == std::string::npos) continue;
        std::string key = line.substr(0, eq);
        std::string val = line.substr(eq + 1);
        if (key == "chunk_size") cfg.chunk_size = std::stoi(val);
        if (key == "in_port")    cfg.in_port    = val;
        if (key == "out_port")   cfg.out_port   = val;
    }
    return cfg;
}

void save_config(const Config& cfg) {
    fs::create_directories(config_path().parent_path());
    std::ofstream f(config_path());
    f << "chunk_size=" << cfg.chunk_size << "\n";
    f << "in_port="    << cfg.in_port    << "\n";
    f << "out_port="   << cfg.out_port   << "\n";
}

// ---------------------------------------------------------------------------
// SysEx codec
// ---------------------------------------------------------------------------

std::vector<uint8_t> syx_enc(const std::vector<uint8_t>& byt) {
    int lng = byt.size();
    std::vector<uint8_t> result;
    std::vector<uint8_t> tmp;
    uint8_t b = 0;
    int cnt = 7, lim = 0;

    for (int i = 0; i < lng; i++) {
        uint8_t e = byt[i];
        if (lng < 7) lim = 7 - lng;
        uint8_t a = e & ~0x80;
        b |= ((e & 0x80) >> cnt);
        tmp.push_back(a);
        cnt--;
        if (cnt == lim) {
            result.push_back(b);
            for (auto x : tmp) result.push_back(x);
            tmp.clear(); b = 0; cnt = 7;
            if ((lng - i) < 7) lim = 7 - (lng - i) + 1;
        }
    }
    return result;
}

// ---------------------------------------------------------------------------
// MIDI
// ---------------------------------------------------------------------------

static RtMidiIn*  g_in  = nullptr;
static RtMidiOut* g_out = nullptr;
static std::vector<uint8_t> g_sysex_buf;
static bool g_sysex_ready = false;

void midi_callback(double, std::vector<uint8_t>* msg, void*) {
    if (!msg || msg->empty()) return;
    if ((*msg)[0] == 0xF0) { g_sysex_buf = *msg; g_sysex_ready = true; }
}

std::vector<uint8_t> wait_sysex(int timeout_ms = 5000) {
    g_sysex_ready = false;
    auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
    while (!g_sysex_ready) {
        if (std::chrono::steady_clock::now() > deadline)
            throw std::runtime_error("Timeout waiting for SysEx response");
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
    return g_sysex_buf;
}

void send_sysex(const std::vector<uint8_t>& data) {
    std::vector<uint8_t> msg = {0xF0};
    for (auto b : data) msg.push_back(b);
    msg.push_back(0xF7);
    g_out->sendMessage(&msg);
}

// ---------------------------------------------------------------------------
// E2 protocol
// ---------------------------------------------------------------------------

struct E2Device {
    uint8_t global_channel = 0;
    uint8_t id = 0x24;
    std::vector<uint8_t> sysex_head;
};

E2Device search_device() {
    send_sysex({0x42, 0x50, 0x00, 0x00});
    auto resp = wait_sysex(5000);
    if (resp.size() < 7 || resp[1] != 0x42 || resp[2] != 0x50 || resp[3] != 0x01)
        throw std::runtime_error("Invalid search response");
    E2Device dev;
    dev.global_channel = 0;
    dev.id = 0x24;
    dev.sysex_head = {0x42, (uint8_t)(0x30 + dev.global_channel), 0x00, 0x01, dev.id};
    return dev;
}

void pivot(const E2Device& dev) {
    std::vector<uint8_t> payload = dev.sysex_head;
    payload.push_back(0x58);
    auto enc = syx_enc(std::vector<uint8_t>(8, 0));
    for (auto b : enc) payload.push_back(b);
    send_sysex(payload);
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}

void test_magic(const E2Device& dev) {
    std::vector<uint8_t> payload = dev.sysex_head;
    for (auto b : std::vector<uint8_t>{0x64,0x01,0x23,0x45,0x67}) payload.push_back(b);
    send_sysex(payload);
    auto resp = wait_sysex(5000);
    if (resp.size() < 9 || resp[5]!=0x76 || resp[6]!=0x54 || resp[7]!=0x32 || resp[8]!=0x10)
        throw std::runtime_error("Magic word failed — loader not active");
}

bool load_chunk(const E2Device& dev, const std::vector<uint8_t>& chunk) {
    auto enc = syx_enc(chunk);
    std::vector<uint8_t> payload = dev.sysex_head;
    payload.push_back(0x54);
    for (auto b : enc) payload.push_back(b);
    send_sysex(payload);
    auto resp = wait_sysex(5000);
    return resp.size() >= 6 && resp[5] == 0x21;
}

void execute(const E2Device& dev) {
    uint32_t address = 0x80000000;
    std::vector<uint8_t> addr_bytes(4), reserved(4, 0);
    for (int i = 0; i < 4; i++) addr_bytes[i] = (address >> (8*i)) & 0xFF;
    std::vector<uint8_t> combined = addr_bytes;
    for (auto b : reserved) combined.push_back(b);
    auto enc = syx_enc(combined);
    std::vector<uint8_t> payload = dev.sysex_head;
    payload.push_back(0x57);
    for (auto b : enc) payload.push_back(b);
    send_sysex(payload);
    wait_sysex(10000);
}

// ---------------------------------------------------------------------------
// ncurses UI
// ---------------------------------------------------------------------------

WINDOW *win_title, *win_status, *win_progress, *win_log, *win_info;

void ui_init() {
    initscr(); cbreak(); noecho(); curs_set(0); start_color();
    init_pair(1, COLOR_CYAN,   COLOR_BLACK);
    init_pair(2, COLOR_GREEN,  COLOR_BLACK);
    init_pair(3, COLOR_RED,    COLOR_BLACK);
    init_pair(4, COLOR_YELLOW, COLOR_BLACK);
    init_pair(5, COLOR_WHITE,  COLOR_BLACK);

    int rows, cols; getmaxyx(stdscr, rows, cols);
    win_title    = newwin(3, cols, 0, 0);
    win_info     = newwin(3, cols, 3, 0);
    win_status   = newwin(3, cols, 6, 0);
    win_progress = newwin(4, cols, 9, 0);
    win_log      = newwin(rows - 13, cols, 13, 0);
    scrollok(win_log, TRUE);

    wattron(win_title, COLOR_PAIR(1)|A_BOLD);
    box(win_title, 0, 0);
    mvwprintw(win_title, 1, 2, " Freetribe Loader  |  Korg Electribe 2  |  press 'c' to configure chunk size ");
    wattroff(win_title, COLOR_PAIR(1)|A_BOLD);
    wrefresh(win_title);
}

void ui_info(const std::string& bin, int chunk, const std::string& in_p, const std::string& out_p) {
    werase(win_info); box(win_info, 0, 0);
    wattron(win_info, COLOR_PAIR(4));
    mvwprintw(win_info, 1, 2, "File: %-30s  Chunk: %d bytes  IN: %s",
              bin.c_str(), chunk, in_p.c_str());
    wattroff(win_info, COLOR_PAIR(4));
    wrefresh(win_info);
}

void ui_status(const std::string& msg, int cp = 5) {
    werase(win_status); box(win_status, 0, 0);
    wattron(win_status, COLOR_PAIR(cp)|A_BOLD);
    mvwprintw(win_status, 1, 2, "%s", msg.c_str());
    wattroff(win_status, COLOR_PAIR(cp)|A_BOLD);
    wrefresh(win_status);
}

void ui_progress(int cur, int total) {
    int cols = getmaxx(win_progress) - 6;
    int filled = total > 0 ? cur * cols / total : 0;
    int pct    = total > 0 ? cur * 100 / total : 0;
    werase(win_progress); box(win_progress, 0, 0);
    mvwprintw(win_progress, 1, 2, "Chunk %d / %d  (%d%%)", cur, total, pct);
    wattron(win_progress, COLOR_PAIR(2));
    mvwprintw(win_progress, 2, 2, "[");
    for (int i = 0; i < cols; i++) wprintw(win_progress, i < filled ? "#" : ".");
    wprintw(win_progress, "]");
    wattroff(win_progress, COLOR_PAIR(2));
    wrefresh(win_progress);
}

void ui_log(const std::string& msg, int cp = 5) {
    wattron(win_log, COLOR_PAIR(cp));
    wprintw(win_log, "%s\n", msg.c_str());
    wattroff(win_log, COLOR_PAIR(cp));
    wrefresh(win_log);
}

void ui_teardown() {
    delwin(win_title); delwin(win_info); delwin(win_status);
    delwin(win_progress); delwin(win_log);
    endwin();
}

// ---------------------------------------------------------------------------
// Port + chunk size selection menus
// ---------------------------------------------------------------------------

int arrow_menu(const std::string& label, const std::vector<std::string>& items) {
    int rows, cols; getmaxyx(stdscr, rows, cols);
    int h = items.size() + 4, w = 64;
    int y = (rows-h)/2, x = (cols-w)/2;
    WINDOW* m = newwin(h, w, y, x);
    keypad(m, TRUE); box(m, 0, 0);
    wattron(m, COLOR_PAIR(1)|A_BOLD);
    mvwprintw(m, 1, 2, "%s", label.c_str());
    wattroff(m, COLOR_PAIR(1)|A_BOLD);
    int sel = 0;
    while (true) {
        for (int i = 0; i < (int)items.size(); i++) {
            if (i==sel) wattron(m, A_REVERSE);
            mvwprintw(m, i+2, 2, "%-*s", w-4, items[i].c_str());
            if (i==sel) wattroff(m, A_REVERSE);
        }
        wrefresh(m);
        int ch = wgetch(m);
        if (ch==KEY_UP   && sel>0)                   sel--;
        if (ch==KEY_DOWN && sel<(int)items.size()-1) sel++;
        if (ch=='\n' || ch==KEY_ENTER) break;
    }
    delwin(m);
    return sel;
}

int chunk_size_menu(int current) {
    int rows, cols; getmaxyx(stdscr, rows, cols);
    WINDOW* m = newwin(7, 50, (rows-7)/2, (cols-50)/2);
    keypad(m, TRUE); box(m, 0, 0);
    wattron(m, COLOR_PAIR(1)|A_BOLD);
    mvwprintw(m, 1, 2, "Set chunk size (current: %d)", current);
    wattroff(m, COLOR_PAIR(1)|A_BOLD);
    mvwprintw(m, 2, 2, "Presets:  [1] 56   [2] 128   [3] 256");
    mvwprintw(m, 3, 2, "Custom:   type a number + Enter");
    mvwprintw(m, 4, 2, "Cancel:   Esc");
    mvwprintw(m, 5, 2, "> ");
    echo(); curs_set(1);
    char buf[16] = {};
    int y = 5, x = 4;
    wmove(m, y, x); wrefresh(m);

    int result = current;
    int ch = wgetch(m);
    if      (ch == '1') result = 56;
    else if (ch == '2') result = 128;
    else if (ch == '3') result = 256;
    else if (ch == 27)  result = current; // Esc
    else if (ch >= '0' && ch <= '9') {
        buf[0] = ch;
        mvwprintw(m, y, x, "%c", ch);
        wrefresh(m);
        wgetnstr(m, buf+1, sizeof(buf)-2);
        try { result = std::stoi(buf); } catch(...) { result = current; }
    }
    noecho(); curs_set(0);
    delwin(m);
    return result > 0 ? result : current;
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

void print_help(const char* prog) {
    std::cout 
"freetribe_loader — Load and execute a Freetribe binary on the Korg Electribe 2\n"
"\n"
"USAGE:\n"
"  " << prog << " <cpu.bin> [OPTIONS]\n"
"\n"
"ARGUMENTS:\n"
"  cpu.bin               Path to the compiled Freetribe binary to transfer\n"
"\n"
"OPTIONS:\n"
"  -h, --help            Show this help message and exit\n"
"  -c, --chunk <size>    Set SysEx chunk size in bytes (default: 56, saved to config)\n"
"                        Larger values transfer faster but may fail with some\n"
"                        USB-MIDI interfaces. Known working values:\n"
"                          56   — safe default (CH345 and most cheap interfaces)\n"
"                          128  — works with better interfaces\n"
"                          256  — original protocol chunk size (requires forked mido)\n"
"  --list-ports          List available MIDI ports and exit\n"
"  --reset-config        Reset saved config (ports + chunk size) and exit\n"
"\n"
"INTERACTIVE CONTROLS:\n"
"  During startup, press 'c' to open the chunk size menu before transferring.\n"
"  Port selection uses arrow keys + Enter.\n"
"\n"
"CONFIG FILE:\n"
"  Settings are saved to: ~/.config/freetribe_loader.conf\n"
"  Saved: chunk_size, in_port, out_port\n"
"\n"
"EXAMPLES:\n"
"  " << prog << " cpu/build/cpu.bin\n"
"  " << prog << " cpu/build/cpu.bin --chunk 128\n"
"  " << prog << " --list-ports\n"
"\n"
"NOTES:\n"
"  - The Electribe 2 must be running Hacktribe firmware (Jan 2025+)\n"
"  - Set MIDI clock to External on the E2 before running\n"
"  - Both MIDI IN and OUT must be connected (E2 OUT -> interface IN, E2 IN -> interface OUT)\n"
"  - Freetribe runs in RAM only; power cycle the E2 to return to Hacktribe\n";
}

void list_ports() {
    RtMidiIn  in;
    RtMidiOut out;
    std::cout << "MIDI INPUT ports:\n";
    for (unsigned i = 0; i < in.getPortCount(); i++)
        std::cout << "  [" << i << "] " << in.getPortName(i) << "\n";
    std::cout << "MIDI OUTPUT ports:\n";
    for (unsigned i = 0; i < out.getPortCount(); i++)
        std::cout << "  [" << i << "] " << out.getPortName(i) << "\n";
}

int main(int argc, char* argv[]) {

    // --- Argument parsing ---
    std::string bin_path;
    int         cli_chunk    = -1;
    bool        do_list      = false;
    bool        do_reset     = false;

    for (int i = 1; i < argc; i++) {
        std::string arg = argv[i];
        if (arg == "-h" || arg == "--help") {
            print_help(argv[0]); return 0;
        } else if (arg == "--list-ports") {
            do_list = true;
        } else if (arg == "--reset-config") {
            do_reset = true;
        } else if ((arg == "-c" || arg == "--chunk") && i+1 < argc) {
            try { cli_chunk = std::stoi(argv[++i]); }
            catch (...) {
                std::cerr << "Error: --chunk requires an integer argument\n"; return 1;
            }
            if (cli_chunk < 7 || cli_chunk > 4096) {
                std::cerr << "Error: chunk size must be between 7 and 4096\n"; return 1;
            }
        } else if (arg[0] == '-') {
            std::cerr << "Unknown option: " << arg << "\n"
                      << "Run with --help for usage.\n"; return 1;
        } else {
            if (!bin_path.empty()) {
                std::cerr << "Error: unexpected argument '" << arg << "'\n"; return 1;
            }
            bin_path = arg;
        }
    }

    if (do_list)  { list_ports(); return 0; }
    if (do_reset) {
        fs::remove(config_path());
        std::cout << "Config reset: " << config_path() << "\n"; return 0;
    }
    if (bin_path.empty()) {
        std::cerr << "Error: no binary file specified.\n"
                  << "Run with --help for usage.\n"; return 1;
    }

    std::ifstream f(bin_path, std::ios::binary);
    if (!f) { std::cerr << "Cannot open: " << bin_path << "\n"; return 1; }
    std::vector<uint8_t> code((std::istreambuf_iterator<char>(f)),
                               std::istreambuf_iterator<char>());
    f.close();

    Config cfg = load_config();

    if (cli_chunk > 0) {
        cfg.chunk_size = cli_chunk;
        save_config(cfg);
    }

    ui_init();

    ui_status("Press 'c' to configure chunk size, any other key to start transfer.", 4);
    nodelay(stdscr, TRUE);
    int ch = getch();
    nodelay(stdscr, FALSE);
    if (ch == 'c') {
        cfg.chunk_size = chunk_size_menu(cfg.chunk_size);
        save_config(cfg);
        ui_log("Chunk size set to " + std::to_string(cfg.chunk_size) + " bytes (saved)", 4);
    }

    try {
        g_in  = new RtMidiIn();
        g_out = new RtMidiOut();

        std::vector<std::string> in_ports, out_ports;
        for (unsigned i = 0; i < g_in->getPortCount();  i++) in_ports.push_back(g_in->getPortName(i));
        for (unsigned i = 0; i < g_out->getPortCount(); i++) out_ports.push_back(g_out->getPortName(i));
        if (in_ports.empty() || out_ports.empty()) throw std::runtime_error("No MIDI ports found");

        int in_sel = 0, out_sel = 0;
        auto find_port = [](const std::vector<std::string>& ports, const std::string& name) {
            for (int i = 0; i < (int)ports.size(); i++)
                if (ports[i].find(name) != std::string::npos) return i;
            return -1;
        };

        if (!cfg.in_port.empty())  in_sel  = std::max(0, find_port(in_ports,  cfg.in_port));
        if (!cfg.out_port.empty()) out_sel  = std::max(0, find_port(out_ports, cfg.out_port));

        in_sel  = arrow_menu("Select MIDI INPUT port  (↑↓ Enter)", in_ports);
        out_sel = arrow_menu("Select MIDI OUTPUT port (↑↓ Enter)", out_ports);

        cfg.in_port  = in_ports[in_sel];
        cfg.out_port = out_ports[out_sel];
        save_config(cfg);

        g_in->openPort(in_sel);
        g_in->setCallback(midi_callback);
        g_in->ignoreTypes(false, true, true);
        g_out->openPort(out_sel);

        ui_info(fs::path(bin_path).filename(), cfg.chunk_size,
                in_ports[in_sel], out_ports[out_sel]);
        ui_log("IN:  " + in_ports[in_sel],  2);
        ui_log("OUT: " + out_ports[out_sel], 2);

        ui_status("Searching for Electribe 2...");
        ui_log("Sending device search...");
        E2Device dev = search_device();
        ui_log("Device found!", 2);

        ui_status("Pivoting to Freetribe loader...");
        ui_log("Sending pivot command...");
        pivot(dev);

        ui_status("Verifying loader...");
        ui_log("Testing magic word...");
        test_magic(dev);
        ui_log("Loader active!", 2);

        int cs = cfg.chunk_size;
        std::vector<std::vector<uint8_t>> chunks;
        for (size_t i = 0; i < code.size(); i += cs) {
            std::vector<uint8_t> chunk(code.begin()+i,
                                       code.begin()+std::min(i+(size_t)cs, code.size()));
            chunk.resize(cs, 0x00);
            chunks.push_back(chunk);
        }
        int total = chunks.size();
        ui_status("Transferring " + std::to_string(total) + " chunks...");
        ui_log("Binary: " + std::to_string(code.size()) + " bytes, " +
               std::to_string(total) + " chunks of " + std::to_string(cs) + " bytes");

        for (int i = 0; i < total; i++) {
            ui_progress(i+1, total);
            if (!load_chunk(dev, chunks[i]))
                throw std::runtime_error("Chunk " + std::to_string(i) + " rejected by device");
        }

        ui_progress(total, total);
        ui_status("Transfer complete! Executing...", 2);
        ui_log("All chunks loaded.", 2);
        execute(dev);
        ui_status("Freetribe is running! Press any key to exit.", 2);
        ui_log("Done.", 2);
        wgetch(win_log);

    } catch (const std::exception& e) {
        ui_status(std::string("ERROR: ") + e.what(), 3);
        ui_log(std::string("Fatal: ") + e.what(), 3);
        ui_log("Press any key to exit.", 5);
        wgetch(win_log);
    }

    ui_teardown();
    if (g_in)  { g_in->closePort();  delete g_in; }
    if (g_out) { g_out->closePort(); delete g_out; }
    return 0;
}

Finally @vanasoft23 thhanks again for your input without you I wouldn't have sort out !
Have a great day !

[vanana-old-acc]

https://docs.google.com/document/d/e/2PACX-1vQ9rHYMmyfvMqh5t-i0FRRobpI8y0Y_QJKlAwxeBxmQs8t5wWfINZ0F_Tawjj3LGm9Cp0LBRnTAvgGj/pub
I put together a soldering guide. Useful in case you decide to go that route in the future. I hope to implement USB app loading from the new bootloader, that would be great.

[lysergik]

Good to know but I'm that skilled with a soldering iron to test that out ! But it's good to know there that documentation somewhere.