swarmit 0.3.0__py3-none-any.whl → 0.4.5__py3-none-any.whl

testbed/swarmit/controller.py

@@ -2,24 +2,24 @@
 
 import dataclasses
 import time
+from binascii import hexlify
 from dataclasses import dataclass
-from typing import Optional
 
-import serial
 from cryptography.hazmat.primitives import hashes
 from dotbot.logger import LOGGER
-from dotbot.protocol import Frame, Header
-from dotbot.serial_interface import SerialInterfaceException, get_default_port
+from dotbot.protocol import Packet, Payload
+from dotbot.serial_interface import get_default_port
 from rich import print
-from rich.console import Console
+from rich.console import Group
 from rich.live import Live
 from rich.table import Table
+from rich.text import Text
 from tqdm import tqdm
 
 from testbed.swarmit.adapter import (
     GatewayAdapterBase,
-    MQTTAdapter,
-    SerialAdapter,
+    MarilibCloudAdapter,
+    MarilibEdgeAdapter,
 )
 from testbed.swarmit.protocol import (
     PayloadMessage,
@@ -27,15 +27,21 @@ from testbed.swarmit.protocol import (
     PayloadOTAStartRequest,
     PayloadResetRequest,
     PayloadStartRequest,
-    PayloadStatusRequest,
     PayloadStopRequest,
     StatusType,
     SwarmitPayloadType,
     register_parsers,
 )
 
-CHUNK_SIZE = 128
+CHUNK_SIZE = 64
+COMMAND_TIMEOUT = 6
+COMMAND_MAX_ATTEMPTS = 5
+COMMAND_ATTEMPT_DELAY = 1
+STATUS_TIMEOUT = 5
+OTA_MAX_RETRIES_DEFAULT = 10
+OTA_ACK_TIMEOUT_DEFAULT = 3
 SERIAL_PORT_DEFAULT = get_default_port()
+BROADCAST_ADDRESS = 0xFFFFFFFFFFFFFFFF
 
 
 @dataclass
@@ -44,6 +50,7 @@ class DataChunk:
 
     index: int
     size: int
+    sha: bytes
     data: bytes
 
 
@@ -53,16 +60,29 @@ class StartOtaData:
 
     chunks: int = 0
     fw_hash: bytes = b""
-    ids: list[str] = dataclasses.field(default_factory=lambda: [])
+    addrs: list[str] = dataclasses.field(default_factory=lambda: [])
+    retries: int = 0
+
+
+@dataclass
+class Chunk:
+    """Class that holds chunk status."""
+
+    index: str = "0"
+    size: str = "0B"
+    acked: int = 0
+    retries: int = 0
+
+    def __repr__(self):
+        return f"{dataclasses.asdict(self)}"
 
 
 @dataclass
 class TransferDataStatus:
     """Class that holds transfer data status for a single device."""
 
-    retries: list[int] = dataclasses.field(default_factory=lambda: [])
-    chunks_acked: set[int] = dataclasses.field(default_factory=lambda: set())
-    hashes_match: bool = False
+    chunks: list[Chunk] = dataclasses.field(default_factory=lambda: [])
+    success: bool = False
 
 
 @dataclass
@@ -76,57 +96,38 @@ class ResetLocation:
         return f"(x={self.pos_x}, y={self.pos_y})"
 
 
-def print_status(status_data: dict[str, StatusType]) -> None:
-    """Print the status of the devices."""
-    print()
-    print(
-        f"{len(status_data)} device{'s' if len(status_data) > 1 else ''} found"
-    )
-    print()
-    status_table = Table()
-    status_table.add_column("Device ID", style="magenta", no_wrap=True)
-    status_table.add_column("Status", style="green", justify="center")
-    with Live(status_table, refresh_per_second=4) as live:
-        live.update(status_table)
-        for device_id, status in sorted(status_data.items()):
-            status_table.add_row(
-                f"{device_id}",
-                f'{"[bold cyan]" if status == StatusType.Running else "[bold green]"}{status.name}',
-            )
+def addr_to_hex(addr: int) -> str:
+    """Convert an address to its hexadecimal representation."""
+    return hexlify(addr.to_bytes(8, "big")).decode().upper()
 
 
-def print_start_status(
-    stopped_data: list[str], not_started: list[str]
-) -> None:
-    """Print the start status."""
-    print("[bold]Start status:[/]")
-    status_table = Table()
-    status_table.add_column("Device ID", style="magenta", no_wrap=True)
-    status_table.add_column("Status", style="green", justify="center")
-    with Live(status_table, refresh_per_second=4) as live:
-        live.update(status_table)
-        for device_id in sorted(stopped_data):
-            status_table.add_row(
-                f"{device_id}", "[bold green]:heavy_check_mark:[/]"
-            )
-        for device_id in sorted(not_started):
-            status_table.add_row(f"{device_id}", "[bold red]:x:[/]")
-
-
-def print_stop_status(stopped_data: list[str], not_stopped: list[str]) -> None:
-    """Print the stop status."""
-    print("[bold]Stop status:[/]")
-    status_table = Table()
-    status_table.add_column("Device ID", style="magenta", no_wrap=True)
-    status_table.add_column("Status", style="green", justify="center")
-    with Live(status_table, refresh_per_second=4) as live:
-        live.update(status_table)
-        for device_id in sorted(stopped_data):
-            status_table.add_row(
-                f"{device_id}", "[bold green]:heavy_check_mark:[/]"
-            )
-        for device_id in sorted(not_stopped):
-            status_table.add_row(f"{device_id}", "[bold red]:x:[/]")
+def generate_status(status_data, devices=[], status_message="found"):
+    data = {
+        key: device
+        for key, device in status_data.items()
+        if (devices and key in devices) or (not devices)
+    }
+    if not data:
+        return Group(Text(f"\nNo device {status_message}\n"))
+
+    header = Text(
+        f"\n{len(data)} device{'s' if len(data) > 1 else ''} {status_message}\n"
+    )
+
+    table = Table()
+    table.add_column("Device Addr", style="magenta", no_wrap=True)
+    table.add_column(
+        "Status",
+        style="green",
+        justify="center",
+        width=max([len(m) for m in StatusType.__members__]),
+    )
+    for device_addr, status in sorted(data.items()):
+        table.add_row(
+            f"{device_addr}",
+            f"{'[bold cyan]' if status == StatusType.Running else '[bold green]'}{status.name}",
+        )
+    return Group(header, table)
 
 
 def print_transfer_status(
@@ -137,26 +138,19 @@ def print_transfer_status(
     print("[bold]Transfer status:[/]")
     transfer_status_table = Table()
     transfer_status_table.add_column(
-        "Device ID", style="magenta", no_wrap=True
+        "Device Addr", style="magenta", no_wrap=True
     )
     transfer_status_table.add_column(
         "Chunks acked", style="green", justify="center"
     )
-    transfer_status_table.add_column(
-        "Hashes match", style="green", justify="center"
-    )
+
     with Live(transfer_status_table, refresh_per_second=4) as live:
         live.update(transfer_status_table)
-        for device_id, status in sorted(status.items()):
-            start_marker, stop_marker = (
-                ("[bold green]", "[/]")
-                if bool(status.hashes_match) is True
-                else ("[bold red]", "[/]")
-            )
+        for device_addr, status in sorted(status.items()):
+            chunks_col_color = "[green]" if status.success else "[bold red]"
             transfer_status_table.add_row(
-                f"{device_id}",
-                f"{len(status.chunks_acked)}/{start_data.chunks}",
-                f"{start_marker}{bool(status.hashes_match)}{stop_marker}",
+                f"{device_addr}",
+                f"{chunks_col_color}{len([chunk for chunk in status.chunks if bool(chunk.acked)])}/{start_data.chunks}",
             )
 
 
@@ -176,10 +170,15 @@ class ControllerSettings:
 
     serial_port: str = SERIAL_PORT_DEFAULT
     serial_baudrate: int = 1000000
-    mqtt_host: str = "argus.paris.inria.fr"
-    mqtt_port: int = 8883
-    edge: bool = False
+    mqtt_host: str = "localhost"
+    mqtt_port: int = 1883
+    mqtt_use_tls: bool = False
+    network_id: int = 1
+    adapter: str = "serial"  # or "mqtt", "marilib-edge", "marilib-cloud"
     devices: list[str] = dataclasses.field(default_factory=lambda: [])
+    ota_max_retries: int = OTA_MAX_RETRIES_DEFAULT
+    ota_timeout: float = OTA_ACK_TIMEOUT_DEFAULT
+    verbose: bool = False
 
 
 class Controller:
@@ -196,43 +195,44 @@ class Controller:
         self.start_ota_data: StartOtaData = StartOtaData()
         self.transfer_data: dict[str, TransferDataStatus] = {}
         self._known_devices: dict[str, StatusType] = {}
-        self.expected_reply: Optional[SwarmitPayloadType] = None
         register_parsers()
-        if self.settings.edge is True:
-            self._interface = MQTTAdapter(
-                self.settings.mqtt_host, self.settings.mqtt_port
+        if self.settings.adapter == "cloud":
+            self._interface = MarilibCloudAdapter(
+                self.settings.mqtt_host,
+                self.settings.mqtt_port,
+                self.settings.mqtt_use_tls,
+                self.settings.network_id,
+                verbose=self.settings.verbose,
             )
         else:
-            try:
-                self._interface = SerialAdapter(
-                    self.settings.serial_port, self.settings.serial_baudrate
-                )
-            except (
-                SerialInterfaceException,
-                serial.serialutil.SerialException,
-            ) as exc:
-                console = Console()
-                console.print(f"[bold red]Error:[/] {exc}")
-        self._interface.init(self.on_data_received)
+            self._interface = MarilibEdgeAdapter(
+                self.settings.serial_port,
+                self.settings.serial_baudrate,
+                verbose=self.settings.verbose,
+            )
+        self._interface.init(self.on_frame_received)
 
     @property
     def known_devices(self) -> dict[str, StatusType]:
         """Return the known devices."""
         if not self._known_devices:
-            self._known_devices = self.status()
+            wait_for_done(COMMAND_TIMEOUT, lambda: False)
+            self._known_devices = self.status_data
         return self._known_devices
 
     @property
     def running_devices(self) -> list[str]:
         """Return the running devices."""
         return [
-            device_id
-            for device_id, status in self.known_devices.items()
+            addr
+            for addr, status in self.known_devices.items()
             if (
-                status == StatusType.Running
+                (
+                    status == StatusType.Running
+                    or status == StatusType.Programming
+                )
                 and (
-                    not self.settings.devices
-                    or device_id in self.settings.devices
+                    not self.settings.devices or addr in self.settings.devices
                 )
             )
         ]
@@ -241,13 +241,13 @@ class Controller:
     def resetting_devices(self) -> list[str]:
         """Return the resetting devices."""
         return [
-            device_id
-            for device_id, status in self.known_devices.items()
+            device_addr
+            for device_addr, status in self.known_devices.items()
             if (
                 status == StatusType.Resetting
                 and (
                     not self.settings.devices
-                    or device_id in self.settings.devices
+                    or device_addr in self.settings.devices
                 )
             )
         ]
@@ -256,13 +256,13 @@ class Controller:
     def ready_devices(self) -> list[str]:
         """Return the ready devices."""
         return [
-            device_id
-            for device_id, status in self.known_devices.items()
+            device_addr
+            for device_addr, status in self.known_devices.items()
             if (
                 status == StatusType.Bootloader
                 and (
                     not self.settings.devices
-                    or device_id in self.settings.devices
+                    or device_addr in self.settings.devices
                 )
             )
         ]
@@ -276,181 +276,176 @@ class Controller:
         """Terminate the controller."""
         self.interface.close()
 
-    def send_frame(self, frame: Frame):
+    def send_payload(self, destination: int, payload: Payload):
         """Send a frame to the devices."""
-        self.interface.send_data(frame.to_bytes())
-
-    def on_data_received(self, data):
-        frame = Frame().from_bytes(data)
-        if frame.payload_type < SwarmitPayloadType.SWARMIT_REQUEST_STATUS:
+        self.interface.send_payload(destination, payload)
+
+    def on_frame_received(self, header, packet: Packet):
+        """Handle the received frame."""
+        # if self.settings.verbose:
+        #     print()
+        #     print(Frame(header, packet))
+        if packet.payload_type < SwarmitPayloadType.SWARMIT_REQUEST_STATUS:
             return
-        device_id = f"{frame.payload.device_id:08X}"
+        device_addr = f"{header.source:08X}"
         if (
-            frame.payload_type
-            == SwarmitPayloadType.SWARMIT_NOTIFICATION_STATUS
-            and self.expected_reply
+            packet.payload_type
             == SwarmitPayloadType.SWARMIT_NOTIFICATION_STATUS
         ):
             self.status_data.update(
-                {device_id: StatusType(frame.payload.status)}
+                {device_addr: StatusType(packet.payload.status)}
             )
         elif (
-            frame.payload_type
-            == SwarmitPayloadType.SWARMIT_NOTIFICATION_STARTED
-            and self.expected_reply
-            == SwarmitPayloadType.SWARMIT_NOTIFICATION_STARTED
-        ):
-            if device_id not in self.started_data:
-                self.started_data.append(device_id)
-        elif (
-            frame.payload_type
-            == SwarmitPayloadType.SWARMIT_NOTIFICATION_STOPPED
-            and self.expected_reply
-            == SwarmitPayloadType.SWARMIT_NOTIFICATION_STOPPED
-        ):
-            if device_id not in self.stopped_data:
-                self.stopped_data.append(device_id)
-        elif (
-            frame.payload_type
-            == SwarmitPayloadType.SWARMIT_NOTIFICATION_OTA_START_ACK
-            and self.expected_reply
+            packet.payload_type
             == SwarmitPayloadType.SWARMIT_NOTIFICATION_OTA_START_ACK
         ):
-            if device_id not in self.start_ota_data.ids:
-                self.start_ota_data.ids.append(device_id)
+            if device_addr in self.start_ota_data.addrs:
+                return
+            self.start_ota_data.addrs.append(device_addr)
         elif (
-            frame.payload_type
+            packet.payload_type
             == SwarmitPayloadType.SWARMIT_NOTIFICATION_OTA_CHUNK_ACK
         ):
-            if (
-                frame.payload.index
-                not in self.transfer_data[device_id].chunks_acked
-            ):
-                self.transfer_data[device_id].chunks_acked.add(
-                    frame.payload.index
+            try:
+                acked = bool(
+                    self.transfer_data[device_addr]
+                    .chunks[packet.payload.index]
+                    .acked
                 )
-            self.transfer_data[device_id].hashes_match = (
-                frame.payload.hashes_match
-            )
-        elif frame.payload_type in [
+            except (IndexError, KeyError):
+                self.logger.warning(
+                    "Chunk index out of range",
+                    device_addr=device_addr,
+                    chunk_index=packet.payload.index,
+                )
+                return
+            if acked is False:
+                self.transfer_data[device_addr].chunks[
+                    packet.payload.index
+                ].acked = 1
+        elif packet.payload_type in [
             SwarmitPayloadType.SWARMIT_NOTIFICATION_EVENT_GPIO,
             SwarmitPayloadType.SWARMIT_NOTIFICATION_EVENT_LOG,
         ]:
             if (
                 self.settings.devices
-                and device_id not in self.settings.devices
+                and device_addr not in self.settings.devices
             ):
                 return
             logger = self.logger.bind(
-                deviceid=device_id,
-                notification=frame.payload_type.name,
-                timestamp=frame.payload.timestamp,
-                data_size=frame.payload.count,
-                data=frame.payload.data,
+                device_addr=device_addr,
+                notification=SwarmitPayloadType(packet.payload_type).name,
+                timestamp=packet.payload.timestamp,
+                data_size=packet.payload.count,
+                data=packet.payload.data,
             )
             if (
-                frame.payload_type
+                packet.payload_type
                 == SwarmitPayloadType.SWARMIT_NOTIFICATION_EVENT_GPIO
             ):
                 logger.info("GPIO event")
             elif (
-                frame.payload_type
+                packet.payload_type
                 == SwarmitPayloadType.SWARMIT_NOTIFICATION_EVENT_LOG
             ):
                 logger.info("LOG event")
-        elif frame.payload_type != self.expected_reply:
-            self.logger.warning(
-                "Unexpected payload",
-                payload_type=hex(frame.payload_type),
-                expected=hex(self.expected_reply),
-            )
         else:
             self.logger.error(
-                "Unknown payload type", payload_type=frame.payload_type
+                "Unknown payload type", payload_type=packet.payload_type
             )
 
+    def _live_status(
+        self, devices=[], timeout=STATUS_TIMEOUT, message="found"
+    ):
+        """Request the live status of the testbed."""
+        with Live(
+            generate_status(self.status_data, devices, status_message=message),
+            refresh_per_second=4,
+        ) as live:
+            while timeout > 0:
+                live.update(
+                    generate_status(
+                        self.status_data, devices, status_message=message
+                    )
+                )
+                timeout -= 0.01
+                time.sleep(0.01)
+
     def status(self):
         """Request the status of the testbed."""
-        self.status_data: dict[str, StatusType] = {}
-        payload = PayloadStatusRequest(device_id=0)
-        frame = Frame(header=Header(), payload=payload)
-        self.expected_reply = SwarmitPayloadType.SWARMIT_NOTIFICATION_STATUS
-        self.send_frame(frame)
-        wait_for_done(1, lambda: False)
-        return self.status_data
-
-    def _send_start(self, device_id: str):
-        def is_started():
-            if device_id == "0":
-                return sorted(self.started_data) == sorted(self.ready_devices)
-            else:
-                return device_id in self.started_data
+        self._live_status(self.settings.devices)
 
-        self.expected_reply = SwarmitPayloadType.SWARMIT_NOTIFICATION_STARTED
-        payload = PayloadStartRequest(device_id=int(device_id, base=16))
-        self.send_frame(Frame(header=Header(), payload=payload))
-        wait_for_done(3, is_started)
-        self.expected_reply = None
+    def _send_start(self, device_addr: str):
+        payload = PayloadStartRequest()
+        self.send_payload(int(device_addr, 16), payload)
 
     def start(self):
         """Start the application."""
-        self.started_data = []
         ready_devices = self.ready_devices
-        if not self.settings.devices:
-            self._send_start("0")
-        else:
-            for device_id in self.settings.devices:
-                if device_id not in ready_devices:
-                    continue
-                self._send_start(device_id)
-        return self.started_data
-
-    def _send_stop(self, device_id: str):
-        stoppable_devices = self.running_devices + self.resetting_devices
-
-        def is_stopped():
-            if device_id == "0":
-                return sorted(self.stopped_data) == sorted(stoppable_devices)
+        attempts = 0
+        while attempts < COMMAND_MAX_ATTEMPTS and not all(
+            self.status_data[addr] == StatusType.Running
+            for addr in ready_devices
+        ):
+            if not self.settings.devices:
+                self._send_start(addr_to_hex(BROADCAST_ADDRESS))
             else:
-                return device_id in self.stopped_data
-
-        self.expected_reply = SwarmitPayloadType.SWARMIT_NOTIFICATION_STOPPED
-        payload = PayloadStopRequest(device_id=int(device_id, base=16))
-        self.send_frame(Frame(header=Header(), payload=payload))
-        wait_for_done(3, is_stopped)
-        self.expected_reply = None
+                for device_addr in self.settings.devices:
+                    if device_addr not in ready_devices:
+                        continue
+                    self._send_start(device_addr)
+            attempts += 1
+            time.sleep(COMMAND_ATTEMPT_DELAY)
+        self._live_status(
+            ready_devices, timeout=COMMAND_TIMEOUT, message="to start"
+        )
 
     def stop(self):
         """Stop the application."""
-        self.stopped_data = []
         stoppable_devices = self.running_devices + self.resetting_devices
-        if not self.settings.devices:
-            self._send_stop("0")
-        else:
-            for device_id in self.settings.devices:
-                if device_id not in stoppable_devices:
-                    continue
-                self._send_stop(device_id)
-        return self.stopped_data
 
-    def _send_reset(self, device_id: str, location: ResetLocation):
+        attempts = 0
+        while attempts < COMMAND_MAX_ATTEMPTS and not all(
+            self.status_data[addr]
+            in [StatusType.Stopping, StatusType.Bootloader]
+            for addr in stoppable_devices
+        ):
+            if not self.settings.devices:
+                self.send_payload(BROADCAST_ADDRESS, PayloadStopRequest())
+            else:
+                for device_addr in self.settings.devices:
+                    if (
+                        device_addr not in stoppable_devices
+                        or self.status_data[device_addr].status
+                        in [StatusType.Stopping, StatusType.Bootloader]
+                    ):
+                        continue
+                    self.send_payload(
+                        int(device_addr, 16), PayloadStopRequest()
+                    )
+            attempts += 1
+            time.sleep(COMMAND_ATTEMPT_DELAY)
+        self._live_status(
+            stoppable_devices, timeout=COMMAND_TIMEOUT, message="to stop"
+        )
+
+    def _send_reset(self, device_addr: int, location: ResetLocation):
         payload = PayloadResetRequest(
-            device_id=int(device_id, base=16),
             pos_x=location.pos_x,
             pos_y=location.pos_y,
         )
-        self.send_frame(Frame(header=Header(), payload=payload))
+        self.send_payload(device_addr, payload)
 
     def reset(self, locations: dict[str, ResetLocation]):
         """Reset the application."""
         ready_devices = self.ready_devices
-        for device_id in self.settings.devices:
-            if device_id not in ready_devices:
+        for device_addr in self.settings.devices:
+            if device_addr not in ready_devices:
                 continue
             print(
-                f"Resetting device {device_id} with location {locations[device_id]}"
+                f"Resetting device {device_addr} with location {locations[device_addr]}"
             )
-            self._send_reset(device_id, locations[device_id])
+            self._send_reset(int(device_addr, 16), locations[device_addr])
 
     def monitor(self):
         """Monitor the testbed."""
@@ -458,44 +453,51 @@ class Controller:
         while True:
             time.sleep(0.01)
 
-    def _send_message(self, device_id, message):
+    def _send_message(self, device_addr: int, message: str):
         payload = PayloadMessage(
-            device_id=int(device_id, base=16),
             count=len(message),
             message=message.encode(),
         )
-        frame = Frame(header=Header(), payload=payload)
-        self.send_frame(frame)
+        self.send_payload(device_addr, payload)
 
     def send_message(self, message):
         """Send a message to the devices."""
         running_devices = self.running_devices
         if not self.settings.devices:
-            self._send_message("0", message)
+            self._send_message(BROADCAST_ADDRESS, message)
         else:
-            for device_id in self.settings.devices:
-                if device_id not in running_devices:
+            for addr in self.settings.devices:
+                if addr not in running_devices:
                     continue
-                self._send_message(device_id, message)
-
-    def _send_start_ota(self, device_id: str, firmware: bytes):
+                self._send_message(int(addr, 16), message)
 
+    def _send_start_ota(
+        self, device_addr: str, devices_to_flash: set[str], firmware: bytes
+    ):
         def is_start_ota_acknowledged():
-            if device_id == "0":
-                return sorted(self.start_ota_data.ids) == sorted(
-                    self.ready_devices
+            if int(device_addr, 16) == BROADCAST_ADDRESS:
+                return sorted(self.start_ota_data.addrs) == sorted(
+                    devices_to_flash
                 )
             else:
-                return device_id in self.start_ota_data.ids
+                return device_addr in self.start_ota_data.addrs
 
         payload = PayloadOTAStartRequest(
-            device_id=int(device_id, base=16),
             fw_length=len(firmware),
             fw_chunk_count=len(self.chunks),
-            fw_hash=self.fw_hash,
         )
-        self.send_frame(Frame(header=Header(), payload=payload))
-        wait_for_done(3, is_start_ota_acknowledged)
+        send_time = time.time()
+        send = True
+        while (
+            not is_start_ota_acknowledged()
+            and self.start_ota_data.retries <= self.settings.ota_max_retries
+        ):
+            if send is True:
+                self.send_payload(int(device_addr, 16), payload)
+                send_time = time.time()
+                self.start_ota_data.retries += 1
+            time.sleep(0.001)
+            send = time.time() - send_time > self.settings.ota_timeout
 
     def start_ota(self, firmware) -> StartOtaData:
         """Start the OTA process."""
@@ -514,107 +516,149 @@ class Controller:
                 chunk_idx * CHUNK_SIZE : chunk_idx * CHUNK_SIZE + chunk_size
             ]
             digest.update(data)
+            chunk_sha = hashes.Hash(hashes.SHA256())
+            chunk_sha.update(data)
             self.chunks.append(
                 DataChunk(
                     index=chunk_idx,
                     size=chunk_size,
+                    sha=chunk_sha.finalize()[
+                        :8
+                    ],  # the first 8 bytes should be enough
                     data=data,
                 )
             )
-        self.fw_hash = digest.finalize()
-        self.expected_reply = (
-            SwarmitPayloadType.SWARMIT_NOTIFICATION_OTA_START_ACK
-        )
-        self.start_ota_data.fw_hash = self.fw_hash
+        self.start_ota_data.fw_hash = digest.finalize()
         self.start_ota_data.chunks = len(self.chunks)
+        devices_to_flash = self.ready_devices
         if not self.settings.devices:
             print("Broadcast start ota notification...")
-            self._send_start_ota("0", firmware)
+            self._send_start_ota(
+                addr_to_hex(BROADCAST_ADDRESS), devices_to_flash, firmware
+            )
         else:
-            for device_id in self.settings.devices:
-                print(f"Sending start ota notification to {device_id}...")
-                self._send_start_ota(device_id, firmware)
-        self.expected_reply = None
-        return self.start_ota_data
-
-    def send_chunk(self, chunk, device_id: str):
-
+            for addr in devices_to_flash:
+                print(f"Sending start ota notification to {addr}...")
+                self._send_start_ota(addr, devices_to_flash, firmware)
+                time.sleep(0.2)
+        return {
+            "ota": self.start_ota_data,
+            "acked": sorted(self.start_ota_data.addrs),
+            "missed": sorted(
+                set(devices_to_flash).difference(
+                    set(self.start_ota_data.addrs)
+                )
+            ),
+        }
+
+    def send_chunk(
+        self,
+        chunk: DataChunk,
+        device_addr: str,
+        devices_to_flash: set[str],
+    ):
         def is_chunk_acknowledged():
-            if device_id == "0":
+            if int(device_addr, 16) == BROADCAST_ADDRESS:
                 return sorted(self.transfer_data.keys()) == sorted(
-                    self.ready_devices
+                    devices_to_flash
                 ) and all(
                     [
-                        chunk.index in status.chunks_acked
+                        status.chunks[chunk.index].acked
                         for status in self.transfer_data.values()
                     ]
                 )
             else:
                 return (
-                    device_id in self.transfer_data.keys()
-                    and chunk.index
-                    in self.transfer_data[device_id].chunks_acked
+                    device_addr in self.transfer_data.keys()
+                    and self.transfer_data[device_addr]
+                    .chunks[chunk.index]
+                    .acked
                 )
 
+        payload = PayloadOTAChunkRequest(
+            index=chunk.index,
+            count=chunk.size,
+            sha=chunk.sha,
+            chunk=chunk.data,
+        )
         send_time = time.time()
         send = True
-        tries = 0
-        while tries < 3:
-            if is_chunk_acknowledged():
-                break
+        retries_count = 0
+        while (
+            not is_chunk_acknowledged()
+            and retries_count <= self.settings.ota_max_retries
+        ):
             if send is True:
-                payload = PayloadOTAChunkRequest(
-                    device_id=int(device_id, base=16),
-                    index=chunk.index,
-                    count=chunk.size,
-                    chunk=chunk.data,
-                )
-                self.send_frame(Frame(header=Header(), payload=payload))
-                if device_id == "0":
-                    for device_id in self.ready_devices:
-                        self.transfer_data[device_id].retries[
+                if self.settings.verbose:
+                    missing_acks = [
+                        addr
+                        for addr in devices_to_flash
+                        if addr not in self.transfer_data
+                        or not self.transfer_data[addr]
+                        .chunks[chunk.index]
+                        .acked
+                    ]
+                    print(
+                        f"Transferring chunk {chunk.index}/{len(self.start_ota_data.chunks)} to {device_addr} "
+                        f"- {retries_count} retries "
+                        f"- {len(missing_acks)} missing acks: {', '.join(missing_acks) if missing_acks else 'none'}"
+                    )
+                self.send_payload(int(device_addr, 16), payload)
+                if int(device_addr, 16) == BROADCAST_ADDRESS:
+                    for addr in devices_to_flash:
+                        self.transfer_data[addr].chunks[
                             chunk.index
-                        ] = tries
+                        ].retries = retries_count
                 else:
-                    self.transfer_data[device_id].retries[chunk.index] = tries
-                tries += 1
-                time.sleep(0.01)
+                    self.transfer_data[device_addr].chunks[
+                        chunk.index
+                    ].retries = retries_count
                 send_time = time.time()
+                retries_count += 1
             time.sleep(0.001)
-            send = time.time() - send_time > 1
+            send = time.time() - send_time > self.settings.ota_timeout
 
-    def transfer(self, firmware):
+    def transfer(self, firmware, devices) -> dict[str, TransferDataStatus]:
         """Transfer the firmware to the devices."""
         data_size = len(firmware)
-        progress = tqdm(
-            range(0, data_size),
-            unit="B",
-            unit_scale=False,
-            colour="green",
-            ncols=100,
-        )
-        progress.set_description(
-            f"Loading firmware ({int(data_size / 1024)}kB)"
-        )
-        self.expected_reply = (
-            SwarmitPayloadType.SWARMIT_NOTIFICATION_OTA_CHUNK_ACK
-        )
+        use_progress_bar = not self.settings.verbose
+        if use_progress_bar:
+            progress = tqdm(
+                range(0, data_size),
+                unit="B",
+                unit_scale=False,
+                colour="green",
+                ncols=100,
+            )
+            progress.set_description(
+                f"Loading firmware ({int(data_size / 1024)}kB)"
+            )
         self.transfer_data = {}
-        if not self.settings.devices:
-            for device_id in self.ready_devices:
-                self.transfer_data[device_id] = TransferDataStatus()
-                self.transfer_data[device_id].retries = [0] * len(self.chunks)
-        else:
-            for device_id in self.settings.devices:
-                self.transfer_data[device_id] = TransferDataStatus()
-                self.transfer_data[device_id].retries = [0] * len(self.chunks)
+        for device_addr in devices:
+            self.transfer_data[device_addr] = TransferDataStatus()
+            self.transfer_data[device_addr].chunks = [
+                Chunk(index=f"{i:03d}", size=f"{self.chunks[i].size:03d}B")
+                for i in range(len(self.chunks))
+            ]
         for chunk in self.chunks:
             if not self.settings.devices:
-                self.send_chunk(chunk, "0")
+                self.send_chunk(
+                    chunk,
+                    addr_to_hex(BROADCAST_ADDRESS),
+                    devices,
+                )
             else:
-                for device_id in self.settings.devices:
-                    self.send_chunk(chunk, device_id)
-            progress.update(chunk.size)
-        progress.close()
-        self.expected_reply = None
+                for addr in devices:
+                    self.send_chunk(chunk, addr, devices)
+            if use_progress_bar:
+                progress.update(chunk.size)
+        if use_progress_bar:
+            progress.close()
+        for device in devices:
+            device_data = self.transfer_data.get(device)
+            if device_data:
+                device_data.success = all(
+                    chunk.acked for chunk in device_data.chunks
+                )
+                self.transfer_data[device] = device_data
         return self.transfer_data