thonny-open-cube 0.1.0__tar.gz

thonny_open_cube-0.1.0/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 Open-Cube
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

thonny_open_cube-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE.md
+include README.md
+recursive-include thonnycontrib *.png

thonny_open_cube-0.1.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: thonny-open-cube
+Version: 0.1.0
+Summary: Open-Cube Bluetooth serial program upload and run plugin for Thonny
+Author: Vaclav Jelinek
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+License-File: LICENSE.md
+Requires-Dist: pyserial
+Requires-Dist: thonny>=4.1.3
+Dynamic: author
+Dynamic: classifier
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

thonny_open_cube-0.1.0/README.md

@@ -0,0 +1,23 @@
+# Thonny Open-Cube Bluetooth Upload Plugin
+
+## Installation
+
+- Download [Open-Cube Thonny plugin](dist/thonny_open_cube-0.1.0-py3-none-any.whl)
+- Open Thonny
+- Tools -> Manage plug-ins... -> Install from local file
+
+## Features
+
+A Thonny plugin for sending programs over Bluetooth to Open-Cube devices and running.
+
+This plugin adds:
+- A new toolbar button: **OC Run**
+- A new toolbar button: **OC Stop**
+- A dockable view for **log messages**
+- A configurable COM port option for Windows and Linux
+- File transfer with feedback using a custom Selective Repeat ARQ protocol
+
+- Automatically uploads the active editor file to the Open-Cube device
+- Runs the uploaded script
+- Configurable serial port in Thonny settings
+- Supports Windows (COM ports) and Linux (`/dev/rfcomm`)

thonny_open_cube-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

thonny_open_cube-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+packages = ["thonnycontrib.open_cube"]
+print(f"Found packages: {packages}")
+
+
+setup(
+    name="thonny-open-cube",
+    version="0.1.0",
+    description="Open-Cube Bluetooth serial program upload and run plugin for Thonny",
+    author="Vaclav Jelinek",
+    packages=packages,
+    include_package_data=True,
+    install_requires=[
+        "pyserial",
+        "thonny >= 4.1.3",
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)

thonny_open_cube-0.1.0/tests/test_program_load_bin.py

@@ -0,0 +1,99 @@
+import importlib.util
+from pathlib import Path
+import sys
+
+
+PLUGIN_ROOT = Path(__file__).resolve().parents[1]
+MODULE_PATH = PLUGIN_ROOT / "thonnycontrib" / "open_cube" / "program_load_bin.py"
+
+
+def load_program_load_bin_module():
+    spec = importlib.util.spec_from_file_location("open_cube_program_load_bin", MODULE_PATH)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Failed to load sender module from {MODULE_PATH}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules.setdefault("open_cube_program_load_bin", module)
+    spec.loader.exec_module(module)
+    return module
+
+
+plb = load_program_load_bin_module()
+
+
+class FakeSerial:
+    def __init__(self, port, baudrate, timeout, responses=None):
+        self.port = port
+        self.baudrate = baudrate
+        self.timeout = timeout
+        self.responses = list(responses or [])
+        self.writes = []
+        self.closed = False
+        self._buffer = b""
+
+    def write(self, data):
+        self.writes.append(data)
+
+    def readline(self):
+        if self.responses:
+            return self.responses.pop(0)
+        return b""
+
+    @property
+    def in_waiting(self):
+        return len(self._buffer)
+
+    def read(self, size):
+        data = self._buffer[:size]
+        self._buffer = self._buffer[size:]
+        return data
+
+    def close(self):
+        self.closed = True
+
+
+def test_chunk_data_splits_payload():
+    chunks = plb.chunk_data(b"abcdefgh", 3)
+    assert chunks == [b"abc", b"def", b"gh"]
+
+
+def test_set_sock_reopens_when_port_changes(monkeypatch):
+    created = []
+
+    def serial_factory(port, baudrate, timeout):
+        fake = FakeSerial(port, baudrate, timeout)
+        created.append(fake)
+        return fake
+
+    monkeypatch.setattr(plb.serial, "Serial", serial_factory)
+    monkeypatch.setattr(plb.time, "sleep", lambda *_args, **_kwargs: None)
+
+    sender = plb.Sender()
+    sender.set_sock("COM7")
+    first = sender.sock
+    sender.set_sock("COM7")
+    sender.set_sock("COM8")
+
+    assert len(created) == 2
+    assert first.closed is True
+    assert sender.sock is created[-1]
+    assert sender.port == "COM8"
+
+
+def test_send_filename_retries_until_cube_ack(monkeypatch):
+    sender = plb.Sender()
+    sender.filename = "demo.py"
+    sender.sock = FakeSerial("COM7", 921600, 0.1, [b"", b"oc prg ok\n"])
+    monkeypatch.setattr(plb.time, "sleep", lambda *_args, **_kwargs: None)
+
+    assert sender.send_filename() is True
+    assert sender.sock.writes == [b"\n", b"oc prg demo.py\n"]
+
+
+def test_build_seq_packet_contains_header_and_crc():
+    sender = plb.Sender()
+    sender.set_content("print('ok')\n", "demo.py", packet_size=8)
+
+    packet = sender.build_seq_packet(0)
+
+    assert packet[:4] == plb.HEADER.to_bytes(4, "big")
+    assert len(packet) > 10

thonny_open_cube-0.1.0/thonny_open_cube.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: thonny-open-cube
+Version: 0.1.0
+Summary: Open-Cube Bluetooth serial program upload and run plugin for Thonny
+Author: Vaclav Jelinek
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+License-File: LICENSE.md
+Requires-Dist: pyserial
+Requires-Dist: thonny>=4.1.3
+Dynamic: author
+Dynamic: classifier
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

thonny_open_cube-0.1.0/thonny_open_cube.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE.md
+MANIFEST.in
+README.md
+setup.py
+tests/test_program_load_bin.py
+thonny_open_cube.egg-info/PKG-INFO
+thonny_open_cube.egg-info/SOURCES.txt
+thonny_open_cube.egg-info/dependency_links.txt
+thonny_open_cube.egg-info/requires.txt
+thonny_open_cube.egg-info/top_level.txt
+thonnycontrib/open_cube/__init__.py
+thonnycontrib/open_cube/btl_logo.png
+thonnycontrib/open_cube/oc_run.png
+thonnycontrib/open_cube/oc_stop.png
+thonnycontrib/open_cube/program_load_bin.py

thonny_open_cube-0.1.0/thonny_open_cube.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

thonny_open_cube-0.1.0/thonny_open_cube.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyserial
+thonny>=4.1.3

thonny_open_cube-0.1.0/thonny_open_cube.egg-info/top_level.txt

@@ -0,0 +1 @@
+thonnycontrib

thonny_open_cube-0.1.0/thonnycontrib/open_cube/__init__.py

@@ -0,0 +1,301 @@
+from thonny import get_workbench
+from thonny.languages import tr
+from tkinter import filedialog, messagebox
+from thonny.tktextext import EnhancedText, TextFrame
+from thonny.ui_utils import TextMenu, AutoScrollbar
+from .program_load_bin import PACKET_TIMEOUT, Sender, PACKET_SIZE
+from thonny.common import is_remote_path
+from thonny.editors import extract_target_path
+from thonny.config_ui import ConfigurationPage
+from thonny.misc_utils import (
+    running_on_linux,
+    running_on_mac_os,
+    running_on_rpi,
+    running_on_windows,
+)
+import tkinter as tk
+from tkinter import ttk
+
+import webbrowser
+import serial.tools.list_ports
+import threading, os, serial
+
+def get_bt_port():
+    wb = get_workbench()
+    view = wb.get_view(OpenCubeView.__name__)
+    port = get_workbench().get_option("oc_bt_run.com_port")
+    if port is not None and "No port found" not in port:
+        return port
+    # fallback
+    view.append_text("run")
+    if running_on_windows():
+        view.append_text("good")
+        return "COM3"
+    else:
+        return "/dev/rfcomm0"
+    
+def get_current_file_content_and_filename():
+    wb = get_workbench()
+    editor = wb.get_editor_notebook().get_current_editor()
+    filepath = editor.get_filename()
+    if filepath is None:
+        return None, None
+    elif is_remote_path(filepath):
+        path = extract_target_path(filepath)
+        filename = path.split("/")[-1]
+    else:
+        filename = os.path.basename(filepath)
+    content = editor.get_content()
+    return content, filename
+
+def open_btl():
+    webbrowser.open("https://btl-kariera.cz/")
+
+def send_stop():
+    wb = get_workbench()
+    view = wb.get_view(OpenCubeView.__name__)
+    view.append_debug("OC Stop pressed")
+    if view.sender.running_program:
+        view.append_text("\n***Stopping program***")
+        view.sender.reset_cube()
+        return
+    if view.sender.running:
+        view.append_text("\n***Stopping upload***")
+        view.sender.abort_upload()
+        return
+
+    #sock_set = view.set_sock()
+    #if not sock_set:
+    #    return
+    
+def send_file_over_serial():
+    wb = get_workbench()
+    view = wb.get_view(OpenCubeView.__name__)
+    view.append_debug("OC Run pressed")
+    wb.show_view(OpenCubeView.__name__, False)
+
+    if view.sender.running:
+        view.append_text("*Sender running*")
+        return
+    
+    sock_set = view.set_sock()
+    if not sock_set:
+        return
+    
+    content, filename = get_current_file_content_and_filename()
+    if content is None:
+        view.append_text("No file selected. Open a file in the editor.")
+        return
+    view.append_text(f"\n***Starting file transfer ({filename})***")
+    packet_size = wb.get_option("oc_bt_run.packet_size")
+    #check if packet size is valid
+    if not isinstance(packet_size, int) or packet_size <= 0 or packet_size > 4096:
+        packet_size = PACKET_SIZE
+    try:
+        packet_timeout = wb.get_option("oc_bt_run.packet_timeout")
+        
+        packet_timeout = float(packet_timeout)/1000
+    except (ValueError, TypeError):
+        packet_timeout = PACKET_TIMEOUT
+    view.append_debug(f"Using packet size: {packet_size}, packet timeout: {packet_timeout}")
+    view.sender.set_content(content, filename, packet_size, packet_timeout)
+
+    view.sender.set_control(wb.get_option("oc_bt_run.take_control"))
+
+    run_after_upload = wb.get_option("oc_bt_run.run_after_upload")
+    view.append_debug("Starting upload thread.")
+    view.upload_thread = threading.Thread(target=view.sender.upload, daemon=True, args=(run_after_upload,))
+    view.upload_thread.start()
+
+class SerialText(EnhancedText):
+    def __init__(self, master, **kw):
+        EnhancedText.__init__(self, master=master, wrap="word", undo=True, **kw)
+        self.context_menu = TextMenu(self)
+
+    def on_secondary_click(self, event=None):
+        super().on_secondary_click(event=event)
+        self.context_menu.tk_popup(event.x_root, event.y_root)
+
+class OpenCubeView(TextFrame):
+    def __init__(self, master):
+        super().__init__(
+            master, text_class=SerialText, horizontal_scrollbar_class=AutoScrollbar
+        )
+        self.text.edit_reset()
+        self.append_text("***Open-Cube upload and run plugin loaded***")
+        self.sender = Sender()
+        self.sender.set_logger(self.append_text)
+        self.sender.set_debug(self.append_debug)
+        self.append_debug(f"Running on Windows: {running_on_windows()}")
+
+    def set_sock(self):
+        try:
+            port = get_bt_port()
+            self.append_debug(f"Used port: {port}")
+            self.sender.set_sock(port)
+        except Exception as e:
+            self.append_text("Please bind Bluetooth socket:")
+            if running_on_windows():
+                self.append_text("Set correct COM port in settings")
+            else:
+                self.append_text("Please bind rfcomm:")
+                self.append_text("sudo rfcomm bind /dev/rfcomm0 <device-MAC>")
+            self.append_text(str(e))
+            return False
+        return True
+
+    def append_text(self, msg):
+        if msg is None:
+            return
+        self.text.config(state="normal")
+        self.text.insert("end", msg + "\n")
+        self.text.config(state="disabled")
+        self.text.see("end")  # Auto-scrol
+        
+    def append_debug(self, msg):
+        if msg is None:
+            return
+        if get_workbench().get_option("oc_bt_run.debug_log"):
+            self.append_text("DEBUG: " + msg)
+
+    def save_content(self, event=None):
+        pass
+    
+    def destroy(self):
+        if self.sender.sock is not None:
+            self.sender.sock.close()
+            self.sender.sock = None
+        super().destroy()
+
+class OpenCubeConfigPage(ConfigurationPage):
+    def __init__(self, master):
+        super().__init__(master)
+
+        self.ports = [p.device for p in serial.tools.list_ports.comports()]
+        if running_on_windows():
+            self.ports = [p for p in self.ports if p.startswith("COM")]
+        else:
+            self.ports = [p for p in self.ports if p.startswith("/dev/rfcomm")]
+        if not self.ports:
+            self.ports = ["No port found"]
+        self.ports.sort()
+
+        self.columnconfigure(1, weight=1)
+
+        self.add_checkbox(
+            "oc_bt_run.run_after_upload",
+            tr("Run after upload"),
+            5,
+            0,
+            columnspan=2,
+            pady=(0, 10),
+        )
+
+        self.add_checkbox(
+            "oc_bt_run.take_control",
+            tr("Take control (allow OC Stop command and wireless printing)"),
+            10,
+            0,
+            columnspan=2,
+            pady=(0, 10),
+        )
+
+        self.add_checkbox(
+            "oc_bt_run.debug_log",
+            tr("Print debug messages"),
+            15,
+            0,
+            columnspan=2,
+            pady=(0, 10),
+        )
+
+        com_port_label = ttk.Label(
+            self,
+            text=tr("Open-Cube BT port")
+        )
+        com_port_label.grid(row=20, column=0, sticky=tk.W)
+        self.add_combobox("oc_bt_run.com_port", 
+                          self.ports, 
+                          20, 
+                          1, 
+                          columnspan=1, 
+                          width=20)
+            
+        packet_size_label = ttk.Label(
+            self,
+            text=tr("Packet size")
+        )
+        packet_size_label.grid(row=30, column=0, sticky=tk.W)
+        self.add_entry("oc_bt_run.packet_size", 
+                       row=30, 
+                       column=1, 
+                       columnspan=1, 
+                       pady=0, 
+                       width=None)
+        
+        packet_timeout_label = ttk.Label(
+            self,
+            text=tr("Packet timeout (ms)")
+        )
+        packet_timeout_label.grid(row=40, column=0, sticky=tk.W)
+        self.add_entry("oc_bt_run.packet_timeout", 
+                       row=40, 
+                       column=1, 
+                       columnspan=1, 
+                       pady=0, 
+                       width=None)
+
+def load_plugin():
+    # Set plugin variables
+    get_workbench().set_default("oc_bt_run.run_after_upload", True)
+    get_workbench().set_default("oc_bt_run.take_control", True)
+    get_workbench().set_default("oc_bt_run.debug_log", False)
+    get_workbench().set_default("oc_bt_run.packet_size", PACKET_SIZE)
+    get_workbench().set_default("oc_bt_run.packet_timeout", PACKET_TIMEOUT*1000)  # Store in milliseconds for easier user input
+    if running_on_windows():
+        get_workbench().set_default("oc_bt_run.com_port", "COM3")
+    else:
+        get_workbench().set_default("oc_bt_run.com_port", "/dev/rfcomm0")
+
+    # Register run command with toolbar icon
+    run_image_path = os.path.join(os.path.dirname(__file__), "oc_run.png")
+    get_workbench().add_command(
+        command_id="oc_upload_run",
+        menu_name="run",
+        command_label="Open-Cube upload and run",
+        handler=send_file_over_serial,
+        include_in_toolbar=True,
+        caption="Open-Cube run",
+        image=run_image_path,
+        group=800,
+    )
+
+    # Register stop command with toolbar icon
+    stop_image_path = os.path.join(os.path.dirname(__file__), "oc_stop.png")
+    get_workbench().add_command(
+        command_id="oc_stop",
+        menu_name="run",
+        command_label="Open-Cube stop",
+        handler=send_stop,
+        include_in_toolbar=True,
+        caption="Open-Cube stop",
+        image=stop_image_path,
+        group=800,
+    )
+
+    # Register BTL butto
+    btl_image_path = os.path.join(os.path.dirname(__file__), "btl_logo.png")
+    get_workbench().add_command(
+        command_id="BTL",
+        menu_name="help",
+        command_label="BTL",
+        handler=open_btl,
+        include_in_toolbar=True,
+        caption="BTL",
+        image=btl_image_path,
+        group=800,
+    )
+    # Add Open-Cube log view
+    get_workbench().add_view(OpenCubeView, tr("Open-Cube log"), "se")
+    # Add Open-Cube config page
+    get_workbench().add_configuration_page("Open-Cube", tr("Open-Cube"), OpenCubeConfigPage, order=85)

thonny_open_cube-0.1.0/thonnycontrib/open_cube/program_load_bin.py

@@ -0,0 +1,459 @@
+import serial
+import time
+import os
+import zlib
+import threading
+import hashlib
+
+
+# Max safe payload is 660 bytes (BT L2CAP default MTU 672 minus 12 bytes
+# packet overhead: 4 header + 2 length + 2 seq + 4 CRC).  Packets above
+# this fragment at the L2CAP layer and become unreliable.  640B works but
+# shows occasional NAKs; 512B is rock-solid with zero NAKs and consistent
+# throughput, so we use it as the default.
+PACKET_SIZE = 512
+WINDOW_SIZE = 20
+ACK_TIMEOUT = 0.4
+RESET_TIMEOUT = 1
+PACKET_TIMEOUT = 0.015
+MIN_PACKET_TIMEOUT = 0.008
+MAX_PACKET_TIMEOUT = 0.015
+HEADER = 0x793F5CFE
+CRC_SIZE = 4
+NUM_ATTEMPTS = 3
+MAX_RESENDS = 3
+
+def chunk_data(data, size):
+    return [data[i:i+size] for i in range(0, len(data), size)]
+
+class Sender:
+    def __init__(self):
+        self.filepath = None
+        self.sock = None
+        self.acked = set()
+        self.naks = set()
+        self.window_end_idx = WINDOW_SIZE
+        self.transfer_complete = False
+        self.transfer_success = False
+        self.cube_abort = False
+        self.logger = None
+        self.debug_logger = None
+        self.progress_callback = None
+        self.ack_thread = None
+        self.running = False
+        self.running_program = False
+        self.port = None
+        self.take_control = False
+        self.state_lock = threading.Lock()
+        self.packet_size = PACKET_SIZE
+        self.packet_timeout = PACKET_TIMEOUT
+
+    def set_sock(self, rfcom_port):
+        if not rfcom_port:
+            if self.sock:
+                self.sock.close()
+                self.sock = None
+                self.debug("Serial port closed.")
+            self.port = None
+            return
+
+        if self.sock and self.port == rfcom_port:
+            self.debug(f"Serial port unchanged {rfcom_port}.")
+            return
+
+        if self.sock:
+            self.sock.close()
+            self.sock = None
+
+        self.port = rfcom_port
+        self.sock = serial.Serial(rfcom_port, 921600, timeout=0.1)
+        time.sleep(1)
+        self.debug(f"Opened serial port {rfcom_port}.")
+
+    def log_and_debug(self, message, logger):
+        if logger is None:
+            print(message)
+        elif hasattr(logger, "insert"):  # Tkinter Text widget
+            logger.insert("end", message + "\n")
+            logger.see("end")
+        elif callable(logger):
+            logger(message)
+
+    def log(self, message):
+        self.log_and_debug(message, self.logger)
+
+    def set_logger(self, logger_widget_or_func):
+        self.logger = logger_widget_or_func
+
+    def debug(self, message):
+        self.log_and_debug(message, self.debug_logger)
+
+    def set_debug(self, debug_widget_or_func):
+        self.debug_logger = debug_widget_or_func
+
+    def set_progress_callback(self, callback_func):
+        self.progress_callback = callback_func
+
+    def set_control(self, take_control=False):
+        self.take_control = take_control
+        self.debug(f"Take control set to {take_control}.")
+
+    def adaptive_delay(self):
+        with self.state_lock:
+            in_flight = self.window_end_idx - len(self.acked)
+        if in_flight < WINDOW_SIZE // 2:
+            time.sleep(MIN_PACKET_TIMEOUT)
+        elif in_flight > WINDOW_SIZE * 3 // 4:
+            time.sleep(MAX_PACKET_TIMEOUT)
+        else:
+            time.sleep((MIN_PACKET_TIMEOUT + MAX_PACKET_TIMEOUT) / 2)
+
+    def reset(self):
+        with self.state_lock:
+            self.acked = set()
+            self.naks = set()
+            self.window_end_idx = WINDOW_SIZE
+        self.transfer_complete = False
+        self.transfer_success = False
+        self.cube_abort = False
+
+    def set_file(self, filepath, packet_size=PACKET_SIZE):
+        self.reset()
+        self.filepath = filepath
+        self.packet_size = packet_size
+        with open(filepath, "rb") as f:
+            self.filedata = f.read()
+        self.filesize = len(self.filedata)
+        self.chunks = chunk_data(self.filedata, packet_size)
+        self.total = len(self.chunks)
+        self.filename = os.path.basename(filepath)
+        self.log(f"File size: {self.filesize} bytes, Number of packets: {self.total}")
+
+    def set_content(self, content, filename, packet_size=PACKET_SIZE, packet_timeout=PACKET_TIMEOUT):
+        self.reset()
+        self.packet_size = packet_size
+        self.filedata = content.encode()
+        self.filesize = len(self.filedata)
+        self.chunks = chunk_data(self.filedata, packet_size)
+        self.total = len(self.chunks)
+        self.filename = filename
+        self.log(f"File size: {self.filesize} bytes, Number of packets: {self.total}")
+        self.packet_timeout = packet_timeout
+    
+    def set_filename(self, filename):
+        self.filename = filename
+
+    def add_seq(self, data, seq):
+        payload_w_seq = seq.to_bytes(2, 'little') + data
+        return payload_w_seq
+    
+    def add_crc(self, payload):
+        crc = zlib.crc32(payload).to_bytes(4, 'little')
+        payload_w_crc = payload + crc
+        return payload_w_crc
+
+    # No crc check on length needed - error in lenght causes complete packet loss
+    def add_len(self, payload_w_crc): 
+        length = len(payload_w_crc).to_bytes(2, 'little')
+        payload_w_len = length + payload_w_crc
+        return payload_w_len
+    
+    def add_header(self, payload):
+        header = HEADER.to_bytes(4, 'big')
+        packet = header + payload
+        return packet
+    
+    def build_seq_packet(self, seq):
+        data = self.chunks[seq]
+        payload_w_seq = self.add_seq(data, seq)
+        packet = self.build_packet(payload_w_seq)
+        return packet
+    
+    def build_packet(self, data):
+        # Build the packet with header, length, CRC
+        payload_w_crc = self.add_crc(data)
+        payload_w_len = self.add_len(payload_w_crc)
+        packet = self.add_header(payload_w_len)
+        return packet
+    
+    def send_packet(self, seq):
+        packet = self.build_seq_packet(seq)
+        self.sock.write(packet)
+        with self.state_lock:
+            acked_count = len(self.acked)
+        self.log(f"Sent packet {seq + 1}/{self.total} ({acked_count * 100 // self.total}%)")
+        if self.progress_callback:
+            self.progress_callback(acked_count, self.total)
+
+    def ping_cube(self):
+        time_start = time.time()
+        attempts = 0
+        while attempts < NUM_ATTEMPTS:
+            attempts += 1
+            self.debug(f"Sending ping attempt {attempts}")
+            self.sock.write(b"oc ping\n")
+            time_start = time.time()
+            while time.time() - time_start < ACK_TIMEOUT:
+                line = self.sock.readline()
+                self.debug(f"Received line: {line}")
+                if b"oc pong" in line:
+                    return True
+        self.debug("Ping failed.")
+        return False
+
+    def send_size(self):
+        data = self.total.to_bytes(2, 'little') + self.packet_size.to_bytes(2, 'little')
+        packet = self.build_packet(data)
+        self.sock.write(packet)  
+
+    def send_filename(self):
+        self.sock.write(b"\n")
+        attempts = 0
+        while attempts < NUM_ATTEMPTS:
+            attempts += 1
+            self.debug(f"Sending command attempt {attempts}: oc prg {self.filename}")
+            self.sock.write(f"oc prg {self.filename}\n".encode())
+            time_start = time.time()
+            while time.time() - time_start < ACK_TIMEOUT:
+                line = self.sock.readline()
+                self.debug(f"Received line: {line}")
+                if b"oc prg ok" in line:
+                    return True
+        return False
+
+    def send_filename_and_size(self):
+        self.debug("Send filename.")
+        if self.send_filename():
+            self.debug("Send size.")
+            self.send_size()
+            return True
+        self.debug("Send filename failed.")
+        return False
+
+    def send_file_end(self):
+        packet = self.build_packet((0xFFFF).to_bytes(2, 'little'))
+        self.sock.write(packet)
+        self.log("Sent end of file packet.")
+
+    def send_file_hash(self):
+        file_hash = hashlib.sha256(self.filedata).digest()
+        data = self.add_seq(file_hash, 0xFFFF)
+        packet = self.build_packet(data)
+        self.sock.write(packet)
+
+    def send_reset(self):
+        self.debug("Sending reset command.")
+        self.sock.write(b"oc rs\n")
+        time.sleep(ACK_TIMEOUT)
+        line = self.sock.readline()
+        if line == b"oc rs ok\n":
+            self.log("Program stopped.")
+
+    def safe_flush(self):
+        try:
+            in_waiting = self.sock.in_waiting
+            if in_waiting > 0:
+                flushed = self.sock.read(in_waiting)
+                self.debug(f"Flushing {in_waiting} bytes from input buffer ({flushed}).")
+                
+        except Exception as e:
+            self.debug(f"Error flushing input buffer: {e}")
+
+    def listen_ack(self):
+        #self.log("Listening for ACK/NAK...")
+        self.debug(f"Start listen thread.")
+        try:
+            while self.running:
+                with self.state_lock:
+                    done = len(self.acked) >= self.total
+                if done:
+                    break
+                try:
+                    msg = self.sock.readline()
+                    if msg.startswith(b"ACK"):
+                        seq = int(msg[3:].decode())
+                        with self.state_lock:
+                            self.window_end_idx += 1
+                            self.acked.add(seq)
+                            self.naks.discard(seq)
+                        self.debug(f"Received ACK for packet {seq}")
+                    elif msg.startswith(b"NAK"):
+                        seq = int(msg[3:].decode())
+                        with self.state_lock:
+                            self.naks.add(seq)
+                        self.debug(f"Received NAK for packet {seq}")
+                    elif msg.startswith(b"oc prg ko"):
+                        self.debug("Received ko from cube.")
+                        self.log("Error sending file.")
+                        self.transfer_complete = True
+                        self.cube_abort = True
+                        break
+                    elif msg != b"":
+                        self.debug(f"Received unknown message: {msg}")
+                except:
+                    pass
+        except Exception as e:
+            self.debug(f"Error in listen thread: {e}")
+        self.debug("Exit listen thread.")
+
+    def reset_cube(self):
+        self.safe_flush()
+        self.running_program = False
+        time.sleep(ACK_TIMEOUT)
+        self.send_reset()
+
+    def _upload(self, run=False):
+        time_start = time.time()
+
+        self.safe_flush()
+        if not self.ping_cube():
+            self.log("Cube not responding.")
+            return
+        
+        self.safe_flush()
+        if not self.send_filename_and_size():
+            self.log("Failed to start transfer.")
+            return
+
+        self.ack_thread = threading.Thread(target=self.listen_ack, daemon=True)
+        self.ack_thread.start()
+
+        resends = 0
+        i = 0
+        while i < self.total and not self.transfer_complete:
+            with self.state_lock:
+                pending_naks = sorted(seq for seq in self.naks if seq < self.total and seq not in self.acked)
+                for seq in pending_naks:
+                    self.naks.discard(seq)
+            for seq in pending_naks:
+                self.send_packet(seq)
+                self.adaptive_delay()
+
+            j = i
+            with self.state_lock:
+                window_end_idx = self.window_end_idx
+                acked = set(self.acked)
+            while j < window_end_idx and j < self.total and not self.transfer_complete:
+                if j not in acked:
+                    self.send_packet(j)
+                    self.adaptive_delay()
+                j += 1
+            resends += 1
+            with self.state_lock:
+                acked = set(self.acked)
+            while i in acked:
+                resends = 0
+                i += 1
+                with self.state_lock:
+                    acked = set(self.acked)
+            #time.sleep(ACK_TIMEOUT)
+            if resends > MAX_RESENDS:
+                self.log("Too many resends, transfer aborted.")
+                self.transfer_complete = True
+                return
+
+        if self.cube_abort: 
+            if self.progress_callback:
+                self.progress_callback(0, self.total)
+            self.log("Transfer aborted from cube.")
+            return
+        elif self.transfer_complete:
+            self.log("Transfer aborted.")
+            return
+        
+        self.safe_flush()
+        attempts = 0
+        while attempts < NUM_ATTEMPTS:
+            attempts += 1
+            self.debug(f"Sending file hash attempt {attempts}")
+            self.send_file_hash()
+            time.sleep(ACK_TIMEOUT)
+            line = self.sock.readline()
+            if line == b'ACK65535\n':
+                self.log("Sent file hash.")
+                self.debug("Received ACK for file hash.")
+                while attempts < NUM_ATTEMPTS*2:
+                    attempts += 1
+                    time.sleep(ACK_TIMEOUT)
+                    line = self.sock.readline()
+                    self.debug(f"Received line: {line}")
+                    if b"oc prg ok" in line:
+                        self.log("File transfer succesful.")
+                        time_end = time.time()
+                        self.log(f"Transfer time: {time_end - time_start:.2f} seconds")
+                        self.transfer_success = True
+                        if self.progress_callback:
+                            self.progress_callback(self.total, self.total)
+                        if run:
+                            time.sleep(ACK_TIMEOUT)
+                            self.run()
+                        return
+                    if b"oc prg hash" in line:
+                        self.log("Hash mismatch, transfer failed.")
+                        if self.progress_callback:
+                            self.progress_callback(0, self.total)
+                        return
+                    if b"oc prg ko" in line:
+                        self.log("Transfer rejected by cube.")
+                        if self.progress_callback:
+                            self.progress_callback(0, self.total)
+                        return
+        if self.progress_callback:
+            self.progress_callback(0, self.total)
+        self.log("Failed to send file hash.")
+
+    def upload(self, run=False):
+        self.debug(f"Starting upload (run: {run})")
+        self.running = True
+        try:
+            self._upload(run=run)
+        except Exception as e:
+            self.debug(f"Exception in upload: {e}")
+            self.set_sock(None)
+        self.running = False
+        self.running_program = False
+        if self.ack_thread is not None and self.ack_thread.is_alive():
+            self.ack_thread.join(timeout=ACK_TIMEOUT)
+        self.debug("Exit upload thread.")
+
+    def upload_and_run(self):
+        self.upload(run=True)
+    
+    def listen_cube(self):
+        self.log("Listening for cube messages:\n")
+        while self.running_program:
+            line = self.sock.readline()
+            if line:
+                if line == b"oc menu\n":
+                    self.log("Program stopped.")
+                    break
+                self.log(line.decode().strip())
+        self.debug("Stop listening cube program.")
+
+    def run(self):
+        if self.filename:
+            self.log("Running program...")
+            if self.take_control:
+                write = "oc rtc "
+            else:
+                write = "oc run "
+            self.safe_flush()
+            attempts = 0
+            while attempts < NUM_ATTEMPTS:
+                attempts += 1
+                self.debug(f"Sending run command attempt {attempts}: {write}{self.filename[:-3]}")
+                self.sock.write(f"{write}{self.filename[:-3]}\n".encode())
+                time.sleep(ACK_TIMEOUT)
+                line = self.sock.readline()
+                if b"oc run ok" in line:
+                    self.log("Program started.")
+                    if self.take_control:
+                        self.running_program = True
+                        self.listen_cube()
+                    return
+                if b"oc run ko" in line:
+                    break
+            self.log("Failed to start program.")
+
+    def abort_upload(self):
+        self.transfer_complete = True