bumble 0.0.211__py3-none-any.whl → 0.0.213__py3-none-any.whl

bumble/apps/bench.py

@@ -23,6 +23,7 @@ import os
 import statistics
 import struct
 import time
+from typing import Optional
 
 import click
 
@@ -35,7 +36,15 @@ from bumble.core import (
     CommandTimeoutError,
 )
 from bumble.colors import color
-from bumble.device import Connection, ConnectionParametersPreferences, Device, Peer
+from bumble.core import ConnectionPHY
+from bumble.device import (
+    CigParameters,
+    CisLink,
+    Connection,
+    ConnectionParametersPreferences,
+    Device,
+    Peer,
+)
 from bumble.gatt import Characteristic, CharacteristicValue, Service
 from bumble.hci import (
     HCI_LE_1M_PHY,
@@ -45,6 +54,7 @@ from bumble.hci import (
     HCI_Constant,
     HCI_Error,
     HCI_StatusError,
+    HCI_IsoDataPacket,
 )
 from bumble.sdp import (
     SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
@@ -55,7 +65,7 @@ from bumble.sdp import (
     DataElement,
     ServiceAttribute,
 )
-from bumble.transport import open_transport_or_link
+from bumble.transport import open_transport
 import bumble.rfcomm
 import bumble.core
 from bumble.utils import AsyncRunner
@@ -75,17 +85,28 @@ DEFAULT_CENTRAL_ADDRESS = 'F0:F0:F0:F0:F0:F0'
 DEFAULT_CENTRAL_NAME = 'Speed Central'
 DEFAULT_PERIPHERAL_ADDRESS = 'F1:F1:F1:F1:F1:F1'
 DEFAULT_PERIPHERAL_NAME = 'Speed Peripheral'
+DEFAULT_ADVERTISING_INTERVAL = 100
 
 SPEED_SERVICE_UUID = '50DB505C-8AC4-4738-8448-3B1D9CC09CC5'
 SPEED_TX_UUID = 'E789C754-41A1-45F4-A948-A0A1A90DBA53'
 SPEED_RX_UUID = '016A2CC7-E14B-4819-935F-1F56EAE4098D'
 
 DEFAULT_RFCOMM_UUID = 'E6D55659-C8B4-4B85-96BB-B1143AF6D3AE'
+
 DEFAULT_L2CAP_PSM = 128
 DEFAULT_L2CAP_MAX_CREDITS = 128
 DEFAULT_L2CAP_MTU = 1024
 DEFAULT_L2CAP_MPS = 1024
 
+DEFAULT_ISO_MAX_SDU_C_TO_P = 251
+DEFAULT_ISO_MAX_SDU_P_TO_C = 251
+DEFAULT_ISO_SDU_INTERVAL_C_TO_P = 10000
+DEFAULT_ISO_SDU_INTERVAL_P_TO_C = 10000
+DEFAULT_ISO_MAX_TRANSPORT_LATENCY_C_TO_P = 35
+DEFAULT_ISO_MAX_TRANSPORT_LATENCY_P_TO_C = 35
+DEFAULT_ISO_RTN_C_TO_P = 3
+DEFAULT_ISO_RTN_P_TO_C = 3
+
 DEFAULT_LINGER_TIME = 1.0
 DEFAULT_POST_CONNECTION_WAIT_TIME = 1.0
 
@@ -102,14 +123,14 @@ def le_phy_name(phy_id):
     )
 
 
-def print_connection_phy(phy):
+def print_connection_phy(phy: ConnectionPHY) -> None:
     logging.info(
         color('@@@ PHY: ', 'yellow') + f'TX:{le_phy_name(phy.tx_phy)}/'
         f'RX:{le_phy_name(phy.rx_phy)}'
     )
 
 
-def print_connection(connection):
+def print_connection(connection: Connection) -> None:
     params = []
     if connection.transport == PhysicalTransport.LE:
         params.append(
@@ -121,9 +142,9 @@ def print_connection(connection):
 
         params.append(
             'Parameters='
-            f'{connection.parameters.connection_interval * 1.25:.2f}/'
+            f'{connection.parameters.connection_interval:.2f}/'
             f'{connection.parameters.peripheral_latency}/'
-            f'{connection.parameters.supervision_timeout * 10} '
+            f'{connection.parameters.supervision_timeout:.2f} '
         )
 
         params.append(f'MTU={connection.att_mtu}')
@@ -134,6 +155,34 @@ def print_connection(connection):
     logging.info(color('@@@ Connection: ', 'yellow') + ' '.join(params))
 
 
+def print_cis_link(cis_link: CisLink) -> None:
+    logging.info(color("@@@ CIS established", "green"))
+    logging.info(color('@@@   ISO interval: ', 'green') + f"{cis_link.iso_interval}ms")
+    logging.info(color('@@@   NSE:          ', 'green') + f"{cis_link.nse}")
+    logging.info(color('@@@   Central->Peripheral:', 'green'))
+    if cis_link.phy_c_to_p is not None:
+        logging.info(
+            color('@@@     PHY:     ', 'green') + f"{cis_link.phy_c_to_p.name}"
+        )
+    logging.info(
+        color('@@@     Latency: ', 'green') + f"{cis_link.transport_latency_c_to_p}µs"
+    )
+    logging.info(color('@@@     BN:      ', 'green') + f"{cis_link.bn_c_to_p}")
+    logging.info(color('@@@     FT:      ', 'green') + f"{cis_link.ft_c_to_p}")
+    logging.info(color('@@@     Max PDU: ', 'green') + f"{cis_link.max_pdu_c_to_p}")
+    logging.info(color('@@@   Peripheral->Central:', 'green'))
+    if cis_link.phy_p_to_c is not None:
+        logging.info(
+            color('@@@     PHY:     ', 'green') + f"{cis_link.phy_p_to_c.name}"
+        )
+    logging.info(
+        color('@@@     Latency: ', 'green') + f"{cis_link.transport_latency_p_to_c}µs"
+    )
+    logging.info(color('@@@     BN:      ', 'green') + f"{cis_link.bn_p_to_c}")
+    logging.info(color('@@@     FT:      ', 'green') + f"{cis_link.ft_p_to_c}")
+    logging.info(color('@@@     Max PDU: ', 'green') + f"{cis_link.max_pdu_p_to_c}")
+
+
 def make_sdp_records(channel):
     return {
         0x00010001: [
@@ -197,6 +246,51 @@ async def switch_roles(connection, role):
             logging.info(f'{color("### Role switch failed:", "red")} {error}')
 
 
+async def pre_power_on(device: Device, classic: bool) -> None:
+    device.classic_enabled = classic
+
+    # Set up a pairing config factory with minimal requirements.
+    device.config.keystore = "JsonKeyStore"
+    device.pairing_config_factory = lambda _: PairingConfig(
+        sc=False, mitm=False, bonding=False
+    )
+
+
+async def post_power_on(
+    device: Device,
+    le_scan: Optional[tuple[int, int]],
+    le_advertise: Optional[int],
+    classic_page_scan: bool,
+    classic_inquiry_scan: bool,
+) -> None:
+    if classic_page_scan:
+        logging.info(color("*** Enabling page scan", "blue"))
+        await device.set_connectable(True)
+    if classic_inquiry_scan:
+        logging.info(color("*** Enabling inquiry scan", "blue"))
+        await device.set_discoverable(True)
+
+    if le_scan:
+        scan_window, scan_interval = le_scan
+        logging.info(
+            color(
+                f"*** Starting LE scanning [{scan_window}ms/{scan_interval}ms]",
+                "blue",
+            )
+        )
+        await device.start_scanning(
+            scan_interval=scan_interval, scan_window=scan_window
+        )
+
+    if le_advertise:
+        logging.info(color(f"*** Starting LE advertising [{le_advertise}ms]", "blue"))
+        await device.start_advertising(
+            advertising_interval_min=le_advertise,
+            advertising_interval_max=le_advertise,
+            auto_restart=True,
+        )
+
+
 # -----------------------------------------------------------------------------
 # Packet
 # -----------------------------------------------------------------------------
@@ -414,7 +508,8 @@ class Sender:
                 self.bytes_sent += len(packet)
                 await self.packet_io.send_packet(packet)
 
-            await self.done.wait()
+            if self.packet_io.can_receive():
+                await self.done.wait()
 
             run_counter = f'[{run + 1} of {self.repeat + 1}]' if self.repeat else ''
             logging.info(color(f'=== {run_counter} Done!', 'magenta'))
@@ -444,6 +539,9 @@ class Sender:
             )
             self.done.set()
 
+    def is_sender(self):
+        return True
+
 
 # -----------------------------------------------------------------------------
 # Receiver
@@ -491,7 +589,8 @@ class Receiver:
             logging.info(
                 color(
                     f'!!! Unexpected packet, expected {self.expected_packet_index} '
-                    f'but received {packet.sequence}'
+                    f'but received {packet.sequence}',
+                    'red',
                 )
             )
 
@@ -534,6 +633,9 @@ class Receiver:
         await self.done.wait()
         logging.info(color('=== Done!', 'magenta'))
 
+    def is_sender(self):
+        return False
+
 
 # -----------------------------------------------------------------------------
 # Ping
@@ -669,7 +771,8 @@ class Ping:
                     color(
                         f'!!! Unexpected packet, '
                         f'expected {self.next_expected_packet_index} '
-                        f'but received {packet.sequence}'
+                        f'but received {packet.sequence}',
+                        'red',
                     )
                 )
 
@@ -677,6 +780,9 @@ class Ping:
             self.done.set()
             return
 
+    def is_sender(self):
+        return True
+
 
 # -----------------------------------------------------------------------------
 # Pong
@@ -721,7 +827,8 @@ class Pong:
             logging.info(
                 color(
                     f'!!! Unexpected packet, expected {self.expected_packet_index} '
-                    f'but received {packet.sequence}'
+                    f'but received {packet.sequence}',
+                    'red',
                 )
             )
 
@@ -743,6 +850,9 @@ class Pong:
         await self.done.wait()
         logging.info(color('=== Done!', 'magenta'))
 
+    def is_sender(self):
+        return False
+
 
 # -----------------------------------------------------------------------------
 # GattClient
@@ -906,6 +1016,9 @@ class StreamedPacketIO:
         # pylint: disable-next=not-callable
         self.io_sink(struct.pack('>H', len(packet)) + packet)
 
+    def can_receive(self):
+        return True
+
 
 # -----------------------------------------------------------------------------
 # L2capClient
@@ -1177,6 +1290,96 @@ class RfcommServer(StreamedPacketIO):
         await self.dlc.drain()
 
 
+# -----------------------------------------------------------------------------
+# IsoClient
+# -----------------------------------------------------------------------------
+class IsoClient(StreamedPacketIO):
+    def __init__(
+        self,
+        device: Device,
+    ) -> None:
+        super().__init__()
+        self.device = device
+        self.ready = asyncio.Event()
+        self.cis_link: Optional[CisLink] = None
+
+    async def on_connection(
+        self, connection: Connection, cis_link: CisLink, sender: bool
+    ) -> None:
+        connection.on(connection.EVENT_DISCONNECTION, self.on_disconnection)
+        self.cis_link = cis_link
+        self.io_sink = cis_link.write
+        await cis_link.setup_data_path(
+            cis_link.Direction.HOST_TO_CONTROLLER
+            if sender
+            else cis_link.Direction.CONTROLLER_TO_HOST
+        )
+        cis_link.sink = self.on_iso_packet
+        self.ready.set()
+
+    def on_iso_packet(self, iso_packet: HCI_IsoDataPacket) -> None:
+        self.on_packet(iso_packet.iso_sdu_fragment)
+
+    def on_disconnection(self, _):
+        pass
+
+    async def drain(self):
+        if self.cis_link is None:
+            return
+        await self.cis_link.drain()
+
+    def can_receive(self):
+        return False
+
+
+# -----------------------------------------------------------------------------
+# IsoServer
+# -----------------------------------------------------------------------------
+class IsoServer(StreamedPacketIO):
+    def __init__(
+        self,
+        device: Device,
+    ):
+        super().__init__()
+        self.device = device
+        self.cis_link: Optional[CisLink] = None
+        self.ready = asyncio.Event()
+
+        logging.info(
+            color(
+                '### Listening for ISO connection',
+                'yellow',
+            )
+        )
+
+    async def on_connection(
+        self, connection: Connection, cis_link: CisLink, sender: bool
+    ) -> None:
+        connection.on(connection.EVENT_DISCONNECTION, self.on_disconnection)
+        self.io_sink = cis_link.write
+        await cis_link.setup_data_path(
+            cis_link.Direction.HOST_TO_CONTROLLER
+            if sender
+            else cis_link.Direction.CONTROLLER_TO_HOST
+        )
+        cis_link.sink = self.on_iso_packet
+        self.ready.set()
+
+    def on_iso_packet(self, iso_packet: HCI_IsoDataPacket) -> None:
+        self.on_packet(iso_packet.iso_sdu_fragment)
+
+    def on_disconnection(self, _):
+        pass
+
+    async def drain(self):
+        if self.cis_link is None:
+            return
+        await self.cis_link.drain()
+
+    def can_receive(self):
+        return False
+
+
 # -----------------------------------------------------------------------------
 # Central
 # -----------------------------------------------------------------------------
@@ -1185,26 +1388,52 @@ class Central(Connection.Listener):
         self,
         transport,
         peripheral_address,
-        classic,
         scenario_factory,
         mode_factory,
         connection_interval,
         phy,
         authenticate,
         encrypt,
+        iso,
+        iso_sdu_interval_c_to_p,
+        iso_sdu_interval_p_to_c,
+        iso_max_sdu_c_to_p,
+        iso_max_sdu_p_to_c,
+        iso_max_transport_latency_c_to_p,
+        iso_max_transport_latency_p_to_c,
+        iso_rtn_c_to_p,
+        iso_rtn_p_to_c,
+        classic,
         extended_data_length,
         role_switch,
+        le_scan,
+        le_advertise,
+        classic_page_scan,
+        classic_inquiry_scan,
     ):
         super().__init__()
         self.transport = transport
         self.peripheral_address = peripheral_address
         self.classic = classic
+        self.iso = iso
+        self.iso_sdu_interval_c_to_p = iso_sdu_interval_c_to_p
+        self.iso_sdu_interval_p_to_c = iso_sdu_interval_p_to_c
+        self.iso_max_sdu_c_to_p = iso_max_sdu_c_to_p
+        self.iso_max_sdu_p_to_c = iso_max_sdu_p_to_c
+        self.iso_max_transport_latency_c_to_p = iso_max_transport_latency_c_to_p
+        self.iso_max_transport_latency_p_to_c = iso_max_transport_latency_p_to_c
+        self.iso_rtn_c_to_p = iso_rtn_c_to_p
+        self.iso_rtn_p_to_c = iso_rtn_p_to_c
         self.scenario_factory = scenario_factory
         self.mode_factory = mode_factory
         self.authenticate = authenticate
         self.encrypt = encrypt or authenticate
         self.extended_data_length = extended_data_length
         self.role_switch = role_switch
+        self.le_scan = le_scan
+        self.le_advertise = le_advertise
+        self.classic_page_scan = classic_page_scan
+        self.classic_inquiry_scan = classic_inquiry_scan
         self.device = None
         self.connection = None
 
@@ -1241,7 +1470,7 @@ class Central(Connection.Listener):
 
     async def run(self):
         logging.info(color('>>> Connecting to HCI...', 'green'))
-        async with await open_transport_or_link(self.transport) as (
+        async with await open_transport(self.transport) as (
             hci_source,
             hci_sink,
         ):
@@ -1254,17 +1483,22 @@ class Central(Connection.Listener):
             mode = self.mode_factory(self.device)
             scenario = self.scenario_factory(mode)
             self.device.classic_enabled = self.classic
+            self.device.cis_enabled = self.iso
 
             # Set up a pairing config factory with minimal requirements.
             self.device.pairing_config_factory = lambda _: PairingConfig(
                 sc=False, mitm=False, bonding=False
             )
 
+            await pre_power_on(self.device, self.classic)
             await self.device.power_on()
-
-            if self.classic:
-                await self.device.set_discoverable(False)
-                await self.device.set_connectable(False)
+            await post_power_on(
+                self.device,
+                self.le_scan,
+                self.le_advertise,
+                self.classic_page_scan,
+                self.classic_inquiry_scan,
+            )
 
             logging.info(
                 color(f'### Connecting to {self.peripheral_address}...', 'cyan')
@@ -1339,7 +1573,72 @@ class Central(Connection.Listener):
                         )
                     )
 
-            await mode.on_connection(self.connection)
+            # Setup ISO streams.
+            if self.iso:
+                if scenario.is_sender():
+                    sdu_interval_c_to_p = (
+                        self.iso_sdu_interval_c_to_p or DEFAULT_ISO_SDU_INTERVAL_C_TO_P
+                    )
+                    sdu_interval_p_to_c = self.iso_sdu_interval_p_to_c or 0
+                    max_transport_latency_c_to_p = (
+                        self.iso_max_transport_latency_c_to_p
+                        or DEFAULT_ISO_MAX_TRANSPORT_LATENCY_C_TO_P
+                    )
+                    max_transport_latency_p_to_c = (
+                        self.iso_max_transport_latency_p_to_c or 0
+                    )
+                    max_sdu_c_to_p = (
+                        self.iso_max_sdu_c_to_p or DEFAULT_ISO_MAX_SDU_C_TO_P
+                    )
+                    max_sdu_p_to_c = self.iso_max_sdu_p_to_c or 0
+                    rtn_c_to_p = self.iso_rtn_c_to_p or DEFAULT_ISO_RTN_C_TO_P
+                    rtn_p_to_c = self.iso_rtn_p_to_c or 0
+                else:
+                    sdu_interval_p_to_c = (
+                        self.iso_sdu_interval_p_to_c or DEFAULT_ISO_SDU_INTERVAL_P_TO_C
+                    )
+                    sdu_interval_c_to_p = self.iso_sdu_interval_c_to_p or 0
+                    max_transport_latency_p_to_c = (
+                        self.iso_max_transport_latency_p_to_c
+                        or DEFAULT_ISO_MAX_TRANSPORT_LATENCY_P_TO_C
+                    )
+                    max_transport_latency_c_to_p = (
+                        self.iso_max_transport_latency_c_to_p or 0
+                    )
+                    max_sdu_p_to_c = (
+                        self.iso_max_sdu_p_to_c or DEFAULT_ISO_MAX_SDU_P_TO_C
+                    )
+                    max_sdu_c_to_p = self.iso_max_sdu_c_to_p or 0
+                    rtn_p_to_c = self.iso_rtn_p_to_c or DEFAULT_ISO_RTN_P_TO_C
+                    rtn_c_to_p = self.iso_rtn_c_to_p or 0
+                cis_handles = await self.device.setup_cig(
+                    CigParameters(
+                        cig_id=1,
+                        sdu_interval_c_to_p=sdu_interval_c_to_p,
+                        sdu_interval_p_to_c=sdu_interval_p_to_c,
+                        max_transport_latency_c_to_p=max_transport_latency_c_to_p,
+                        max_transport_latency_p_to_c=max_transport_latency_p_to_c,
+                        cis_parameters=[
+                            CigParameters.CisParameters(
+                                cis_id=2,
+                                max_sdu_c_to_p=max_sdu_c_to_p,
+                                max_sdu_p_to_c=max_sdu_p_to_c,
+                                rtn_c_to_p=rtn_c_to_p,
+                                rtn_p_to_c=rtn_p_to_c,
+                            )
+                        ],
+                    )
+                )
+                cis_link = (
+                    await self.device.create_cis([(cis_handles[0], self.connection)])
+                )[0]
+                print_cis_link(cis_link)
+
+                await mode.on_connection(
+                    self.connection, cis_link, scenario.is_sender()
+                )
+            else:
+                await mode.on_connection(self.connection)
 
             await scenario.run()
             await asyncio.sleep(DEFAULT_LINGER_TIME)
@@ -1375,24 +1674,38 @@ class Peripheral(Device.Listener, Connection.Listener):
         scenario_factory,
         mode_factory,
         classic,
+        iso,
         extended_data_length,
         role_switch,
+        le_scan,
+        le_advertise,
+        classic_page_scan,
+        classic_inquiry_scan,
     ):
         self.transport = transport
         self.classic = classic
+        self.iso = iso
         self.scenario_factory = scenario_factory
         self.mode_factory = mode_factory
         self.extended_data_length = extended_data_length
         self.role_switch = role_switch
+        self.le_scan = le_scan
+        self.classic_page_scan = classic_page_scan
+        self.classic_inquiry_scan = classic_inquiry_scan
         self.scenario = None
         self.mode = None
         self.device = None
         self.connection = None
         self.connected = asyncio.Event()
 
+        if le_advertise:
+            self.le_advertise = le_advertise
+        else:
+            self.le_advertise = 0 if classic else DEFAULT_ADVERTISING_INTERVAL
+
     async def run(self):
         logging.info(color('>>> Connecting to HCI...', 'green'))
-        async with await open_transport_or_link(self.transport) as (
+        async with await open_transport(self.transport) as (
             hci_source,
             hci_sink,
         ):
@@ -1406,19 +1719,22 @@ class Peripheral(Device.Listener, Connection.Listener):
             self.mode = self.mode_factory(self.device)
             self.scenario = self.scenario_factory(self.mode)
             self.device.classic_enabled = self.classic
+            self.device.cis_enabled = self.iso
 
             # Set up a pairing config factory with minimal requirements.
             self.device.pairing_config_factory = lambda _: PairingConfig(
                 sc=False, mitm=False, bonding=False
             )
 
+            await pre_power_on(self.device, self.classic)
             await self.device.power_on()
-
-            if self.classic:
-                await self.device.set_discoverable(True)
-                await self.device.set_connectable(True)
-            else:
-                await self.device.start_advertising(auto_restart=True)
+            await post_power_on(
+                self.device,
+                self.le_scan,
+                self.le_advertise,
+                self.classic or self.classic_page_scan,
+                self.classic or self.classic_inquiry_scan,
+            )
 
             if self.classic:
                 logging.info(
@@ -1440,7 +1756,21 @@ class Peripheral(Device.Listener, Connection.Listener):
             logging.info(color('### Connected', 'cyan'))
             print_connection(self.connection)
 
-            await self.mode.on_connection(self.connection)
+            if self.iso:
+
+                async def on_cis_request(cis_link: CisLink) -> None:
+                    logging.info(color("@@@ Accepting CIS", "green"))
+                    await self.device.accept_cis_request(cis_link)
+                    print_cis_link(cis_link)
+
+                    await self.mode.on_connection(
+                        self.connection, cis_link, self.scenario.is_sender()
+                    )
+
+                self.connection.on(self.connection.EVENT_CIS_REQUEST, on_cis_request)
+            else:
+                await self.mode.on_connection(self.connection)
+
             await self.scenario.run()
             await asyncio.sleep(DEFAULT_LINGER_TIME)
 
@@ -1449,10 +1779,14 @@ class Peripheral(Device.Listener, Connection.Listener):
         self.connection = connection
         self.connected.set()
 
-        # Stop being discoverable and connectable
+        # Stop being discoverable and connectable if possible
         if self.classic:
-            AsyncRunner.spawn(self.device.set_discoverable(False))
-            AsyncRunner.spawn(self.device.set_connectable(False))
+            if not self.classic_inquiry_scan:
+                logging.info(color("*** Stopping inquiry scan", "blue"))
+                AsyncRunner.spawn(self.device.set_discoverable(False))
+            if not self.classic_page_scan:
+                logging.info(color("*** Stopping page scan", "blue"))
+                AsyncRunner.spawn(self.device.set_connectable(False))
 
         # Request a new data length if needed
         if not self.classic and self.extended_data_length:
@@ -1473,7 +1807,9 @@ class Peripheral(Device.Listener, Connection.Listener):
         self.scenario.reset()
 
         if self.classic:
+            logging.info(color("*** Enabling inquiry scan", "blue"))
             AsyncRunner.spawn(self.device.set_discoverable(True))
+            logging.info(color("*** Enabling page scan", "blue"))
             AsyncRunner.spawn(self.device.set_connectable(True))
 
     def on_connection_parameters_update(self):
@@ -1546,6 +1882,12 @@ def create_mode_factory(ctx, default_mode):
                 credits_threshold=ctx.obj['rfcomm_credits_threshold'],
             )
 
+        if mode == 'iso-server':
+            return IsoServer(device)
+
+        if mode == 'iso-client':
+            return IsoClient(device)
+
         raise ValueError('invalid mode')
 
     return create_mode
@@ -1573,6 +1915,9 @@ def create_scenario_factory(ctx, default_scenario):
             return Receiver(packet_io, ctx.obj['linger'])
 
         if scenario == 'ping':
+            if isinstance(packet_io, (IsoClient, IsoServer)):
+                raise ValueError('ping not supported with ISO')
+
             return Ping(
                 packet_io,
                 start_delay=ctx.obj['start_delay'],
@@ -1584,6 +1929,9 @@ def create_scenario_factory(ctx, default_scenario):
             )
 
         if scenario == 'pong':
+            if isinstance(packet_io, (IsoClient, IsoServer)):
+                raise ValueError('pong not supported with ISO')
+
             return Pong(packet_io, ctx.obj['linger'])
 
         raise ValueError('invalid scenario')
@@ -1607,6 +1955,8 @@ def create_scenario_factory(ctx, default_scenario):
             'l2cap-server',
             'rfcomm-client',
             'rfcomm-server',
+            'iso-client',
+            'iso-server',
         ]
     ),
 )
@@ -1619,6 +1969,7 @@ def create_scenario_factory(ctx, default_scenario):
 )
 @click.option(
     '--extended-data-length',
+    metavar='<TX-OCTETS>/<TX-TIME>',
     help='Request a data length upon connection, specified as tx_octets/tx_time',
 )
 @click.option(
@@ -1626,6 +1977,26 @@ def create_scenario_factory(ctx, default_scenario):
     type=click.Choice(['central', 'peripheral']),
     help='Request role switch upon connection (central or peripheral)',
 )
+@click.option(
+    '--le-scan',
+    metavar='<WINDOW>/<INTERVAL>',
+    help='Perform an LE scan with a given window and interval (milliseconds)',
+)
+@click.option(
+    '--le-advertise',
+    metavar='<INTERVAL>',
+    help='Advertise with a given interval (milliseconds)',
+)
+@click.option(
+    '--classic-page-scan',
+    is_flag=True,
+    help='Enable Classic page scanning',
+)
+@click.option(
+    '--classic-inquiry-scan',
+    is_flag=True,
+    help='Enable Classic enquiry scanning',
+)
 @click.option(
     '--rfcomm-channel',
     type=int,
@@ -1751,6 +2122,10 @@ def bench(
     att_mtu,
     extended_data_length,
     role_switch,
+    le_scan,
+    le_advertise,
+    classic_page_scan,
+    classic_inquiry_scan,
     packet_size,
     packet_count,
     start_delay,
@@ -1799,7 +2174,12 @@ def bench(
         else None
     )
     ctx.obj['role_switch'] = role_switch
+    ctx.obj['le_scan'] = [float(x) for x in le_scan.split('/')] if le_scan else None
+    ctx.obj['le_advertise'] = float(le_advertise) if le_advertise else None
+    ctx.obj['classic_page_scan'] = classic_page_scan
+    ctx.obj['classic_inquiry_scan'] = classic_inquiry_scan
     ctx.obj['classic'] = mode in ('rfcomm-client', 'rfcomm-server')
+    ctx.obj['iso'] = mode in ('iso-client', 'iso-server')
 
 
 @bench.command()
@@ -1821,28 +2201,94 @@ def bench(
 @click.option('--phy', type=click.Choice(['1m', '2m', 'coded']), help='PHY to use')
 @click.option('--authenticate', is_flag=True, help='Authenticate (RFComm only)')
 @click.option('--encrypt', is_flag=True, help='Encrypt the connection (RFComm only)')
+@click.option(
+    '--iso-sdu-interval-c-to-p',
+    type=int,
+    help='ISO SDU central -> peripheral (microseconds)',
+)
+@click.option(
+    '--iso-sdu-interval-p-to-c',
+    type=int,
+    help='ISO SDU interval peripheral -> central (microseconds)',
+)
+@click.option(
+    '--iso-max-sdu-c-to-p',
+    type=int,
+    help='ISO max SDU central -> peripheral',
+)
+@click.option(
+    '--iso-max-sdu-p-to-c',
+    type=int,
+    help='ISO max SDU peripheral -> central',
+)
+@click.option(
+    '--iso-max-transport-latency-c-to-p',
+    type=int,
+    help='ISO max transport latency central -> peripheral (milliseconds)',
+)
+@click.option(
+    '--iso-max-transport-latency-p-to-c',
+    type=int,
+    help='ISO max transport latency peripheral -> central (milliseconds)',
+)
+@click.option(
+    '--iso-rtn-c-to-p',
+    type=int,
+    help='ISO RTN central -> peripheral (integer count)',
+)
+@click.option(
+    '--iso-rtn-p-to-c',
+    type=int,
+    help='ISO RTN peripheral -> central (integer count)',
+)
 @click.pass_context
 def central(
-    ctx, transport, peripheral_address, connection_interval, phy, authenticate, encrypt
+    ctx,
+    transport,
+    peripheral_address,
+    connection_interval,
+    phy,
+    authenticate,
+    encrypt,
+    iso_sdu_interval_c_to_p,
+    iso_sdu_interval_p_to_c,
+    iso_max_sdu_c_to_p,
+    iso_max_sdu_p_to_c,
+    iso_max_transport_latency_c_to_p,
+    iso_max_transport_latency_p_to_c,
+    iso_rtn_c_to_p,
+    iso_rtn_p_to_c,
 ):
     """Run as a central (initiates the connection)"""
     scenario_factory = create_scenario_factory(ctx, 'send')
     mode_factory = create_mode_factory(ctx, 'gatt-client')
-    classic = ctx.obj['classic']
 
     async def run_central():
         await Central(
             transport,
             peripheral_address,
-            classic,
             scenario_factory,
             mode_factory,
             connection_interval,
             phy,
             authenticate,
             encrypt or authenticate,
+            ctx.obj['iso'],
+            iso_sdu_interval_c_to_p,
+            iso_sdu_interval_p_to_c,
+            iso_max_sdu_c_to_p,
+            iso_max_sdu_p_to_c,
+            iso_max_transport_latency_c_to_p,
+            iso_max_transport_latency_p_to_c,
+            iso_rtn_c_to_p,
+            iso_rtn_p_to_c,
+            ctx.obj['classic'],
             ctx.obj['extended_data_length'],
             ctx.obj['role_switch'],
+            ctx.obj['le_scan'],
+            ctx.obj['le_advertise'],
+            ctx.obj['classic_page_scan'],
+            ctx.obj['classic_inquiry_scan'],
         ).run()
 
     asyncio.run(run_central())
@@ -1862,8 +2308,13 @@ def peripheral(ctx, transport):
             scenario_factory,
             mode_factory,
             ctx.obj['classic'],
+            ctx.obj['iso'],
             ctx.obj['extended_data_length'],
             ctx.obj['role_switch'],
+            ctx.obj['le_scan'],
+            ctx.obj['le_advertise'],
+            ctx.obj['classic_page_scan'],
+            ctx.obj['classic_inquiry_scan'],
         ).run()
 
     asyncio.run(run_peripheral())