edr | Blog post describing EDR : Building Rich Domain Models | Application Framework library

There's many issues. If you use modern C++ and compiler warnings, you can reduce the code and spot the bugs in printing vertex descriptors (printf is just not safe; use the diagnostics!).

Here's my take after review.

Notable changes:

• bundled properties instead of separate interior properties

• this implies passing named arguments (but see https://stackoverflow.com/a/64744086/85371)

• no more global variables, no more loopy initialization if the simple constructor suffices

• no more duplicated code (nothing invites error quite like having capacities1 and capacities2 lying around)

• using clear_vertex instead of just clear_out_edges - this may not make a difference (?) but seems to express intent a bit better

• no more printf (I'll use libfmt, which is also in c++23), so e.g.

If we talk about BLE, the three different PHYs are quite similar from the radio point of view. What you need to know is that they all usually consume basically the same current (not energy) while the radio is on (with some small differences). The difference is that the radio needs to be on for longer times with shorter bitrates (and hence consume more energy in total) and shorter times with higher bitrates. Higher bitrates lead to worse delivery success rate than lower bitrates. So everything is just a tradeoff between range, speed and energy usage.

Note that a BLE radio can typically only do one radio operation at a time, so with the LE packet length extension, a maximum length Coded PHY packet can take 17 ms, which might reduce the ability for the firmware to schedule other activities, such as scanning or handle another connection. On the Link Layer, the two endpoints can negotiate the maximum time and maximum packet size, so yes, you can end up in a situation where the maximum packet length depends on the PHY used (but the link layer will segment it so it won't be any issues for the host side). You can also realise that with 2M PHY you can fit much more packets compared with other PHYs during a certain amount of time, for example one connection event with a firmware-decided deadline when it must end.

Also keep in mind that to establish a connection using Coded PHY, you need to use the new "extended advertisements", which are not backwards-compatible with devices not supporting Coded PHY, or devices that support Coded PHY but are not set up to scan using Coded PHY.

When a connection is established, you can change PHY at any time. For example if you monitor the RSSI and detect a change in signal quality you can change the PHY.

The ATT MTU is decided by the host layer and is completely separate from the link layer. Although, of course a programmer could for some reason decide to use shorter MTUs when Coded PHY is used, but I haven't heard about anyone doing so.

Don't forget that you can also change the TX power of your radio to increase the range (and current consumption) your sent packets will reach. You can also select a chip with better RX sensitivity to get better range when receiving packets. Or use an antenna amplifier.

First of all, this question is not suitable to be asked on SO, as it does not involve any coding problem at all, but refers to specifications. Nevertheless, I will give you an answer.

The Diffie–Hellman key exchange (or Elliptic-Curve Diffie–Hellman (ECDH) if operating on elliptic curves) is - as its name states - a protocol for exchanging / generating cryptographic key material. It is not about the actual data encryption nor about the actual data integrity.

E0 on the other hand is an encryption algorithm used for actually encrypting data - but also not for authentication (integrity) of encrypted data.

Regarding BR/EDR key-exchange, authentication and encryption, you can find a nice overview in Table 1.1: Security algorithms in the [BR/EDR Controller] Security Specification (Bluetooth Core Specification Version 5.2 [Vol 2] Part H [Section 1]).

To summarize it for you, the Security Mechanisms Legacy and Secure Simple Pairing both use E0 for encryption, while Secure Connections uses AES-CCM.

Note, that Secure Simple Pairing and Secure Connections both use ECDH for key generation, while Legacy uses SAFER+.

Encryption on the LE Link Layer is performed using AES-CCM, as described in [Low Energy Controller] Low Energy Link Layer Security (Bluetooth Core Specification Version 5.2 [Vol 6] Part E).

The actual encryption on the Link Layer needs some cryptographic keys, which are derived / calculated during pairing using the methods described in the [Host] Security Manager Specification (Bluetooth Core Specification Version 5.2 [Vol 3] Part H).

To summarize it for you, there are LE legacy pairing (Short Term Key (STK) Generation) and LE Secure Connections (Long Term Key (LTK) Generation).

Note that both are about key-generation / exchange, while LE legacy pairing uses (somehow) AES and LE Secure Connections uses ECDH.

hcitool and gatttool were some of the tools that were deprecated by the BlueZ project in 2017. If you are following a tutorial that uses them, there is a chance that it might be out of date. The correct tool to be using now is bluetoothctl.

If you are new to Bluetooth then using a generic Bluetooth Low Energy scanning and exploration tool like nRF Connect might be more helpful to understand what is going on. Reading up on how BLE GATT services work will help with the service > Characteristics information.

Once you can read and write with the characteristics, your next challenge will be to work out what the binary data that is being sent/received means as it looks like they are using a lot of custom characteristics.

We can use intersect to get the intersecting 'ID' from all the datasets . Then, use that to subset the individual datasets

It seems you run dask and jupyterlab in docker ?

Maybe you should add some flags like fellowing:

it seems likely you're not only re-initializing tf for each frame, but you're starting a new process for each frame, then killing it after it's done. One of the benefits of a Pool is letting some initialization happen in the child process, then keeping it around to execute multiple tasks. I think a simple solution would probably be re-arranging your code to look something like this, though it's hard to know with what you've posted.

It should be possible to connect to BLE devices to your Raspberry Pi at the same time. You mention about the CSR 4.0 dongle so your setup might vary from a typical setup because you have two adapters?

I suspect if you listed your Bluez service you will have hci0 and hci1 representing the inbuilt adapter and the CSR dongle. In the list will also be the devices that you have paired with. You will need to use the correct hci path for the devices you want to connect to