Your first node in 3 steps
Select your environment, install the SDK, and run a live DaaS IoT node — then follow the links to the full documentation.
Choose your SDK
Pick the SDK you want to integrate. Availability and supported platforms come from the latest release.
Install Python
Installation guide bundled with the SDK.
pydaasiot — Installation Guide
Python bindings for the DaaS-IoT SDK.
Package 0.2.33 · DaaS-IoT core v0.22.0 · Python >= 3.7.
Install pydaasiot from PyPI with pip:
pip install pydaasiot
For offline installs or platforms without a matching wheel, you can also install from a prebuilt wheel or build from source.
Requirements
| Python | 3.7 – 3.12 (64-bit) |
| OS | Linux (x86_64 ✅, aarch64 ✅, armv7 🧪), Windows x64 🧪 |
| Compiler (source build only) | GCC/G++ ≥ 9 (Linux) or MSVC 2019+ (Windows), C++17 |
| CMake (source build only) | ≥ 3.16 |
See architectures.md for the full support matrix.
It is strongly recommended to work inside a virtual environment:
python -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
python -m pip install --upgrade pip
1. Install from a prebuilt wheel
If your SDK release ships a .whl matching your platform and Python version:
pip install ./pydaasiot-0.2.33-cp311-cp311-linux_x86_64.whl
Wheel filenames encode the Python version (cp311 = CPython 3.11) and platform
(linux_x86_64, win_amd64, …). Pick the one that matches your interpreter:
python -c "import platform, sys; print(sys.version, platform.machine())"
Linux BLE note: if you use the Bluetooth driver, install the runtime library:
sudo apt-get install -y libbluetooth3
Verify the installation:
python -c "import pydaasiot; print(pydaasiot.__doc__)"
2. Build from source
The bindings are compiled with scikit-build-core + pybind11 and link against
the precompiled libdaas.a shipped in lib/.
2.1 Linux
Install the build dependencies:
sudo apt-get update
sudo apt-get install -y build-essential cmake python3-dev libbluetooth-dev
Build and install the package:
git clone <repo-url> daasiot-python
cd daasiot-python
pip install .
For an editable/development build:
pip install -e . --no-build-isolation
The build downloads pybind11==2.13.6 and scikit-build-core==0.8.2
automatically (declared in pyproject.toml).
2.2 Windows
Requirements: Visual Studio 2019+ (Desktop C++ workload), CMake, Python 3.8+.
py -m venv .venv
.\.venv\Scripts\activate
py -m pip install --upgrade pip
pip install .
The build produces pydaasiot.pyd.
2.3 Cross-compile for armv7 / armhf
A toolchain file is provided for 32-bit ARM hard-float targets (Raspberry Pi 2 / Zero 2, BeagleBone):
sudo apt-get install -y g++-arm-linux-gnueabihf
cmake -S . -B build \
-DCMAKE_TOOLCHAIN_FILE=cmake/toolchain-armv7-linux-gnueabihf.cmake \
-DCMAKE_BUILD_TYPE=Release
cmake --build build -- -j"$(nproc)"
Copy the resulting pydaasiot*.so onto the target device and place it where
Python can import it.
Verify
python -c "import pydaasiot; print(pydaasiot)"
A quick smoke test:
import pydaasiot
node = pydaasiot.DaasWrapper(None, None)
err = node.doInit(100, 102)
print("doInit:", node.errorToString(err))
node.doEnd()
Troubleshooting
| Symptom | Cause / fix |
|---|---|
ImportError: ... undefined symbol: pthread_* |
Missing pthread at link time — rebuild with build-essential installed. |
ImportError: libbluetooth.so.3: cannot open shared object file |
Install libbluetooth3 (runtime) / libbluetooth-dev (build). |
ModuleNotFoundError: No module named 'pydaasiot' |
The .so/.pyd is not on sys.path; install the wheel or copy the module next to your script. |
Wheel ... is not a supported wheel on this platform |
Python version / architecture mismatch — pick the wheel matching cp<XY> and your machine arch, or build from source. |
libdaas.a not found during build |
Ensure lib/libdaas.a is present, or point CMake to it with -DDAAS_LIBRARY_FILE=/path/to/libdaas.a. |
For the API surface, see reference.md.
For runnable examples, see the examples/ folder.
© Sebyone Srl — info@sebyone.it
Run your first node
Ready-to-run examples straight from the Python SDK.
import time
import pydaasiot
SID = 100
SENDER_DIN = 102
RECEIVER_DIN = 101
SENDER_URI = "127.0.0.1:2223"
RECEIVER_URI = "127.0.0.1:2222"
class MyHandler(pydaasiot.IDaasApiEvent):
def dinAccepted(self, din):
print(f"[EVENT] DIN accepted: {din}")
def ddoReceived(self, payload_size, typeset, din):
print(
f"[EVENT] DDO received on sender side: "
f"din={din}, size={payload_size}, typeset={typeset}"
)
def frisbeeReceived(self, din):
print(f"[EVENT] FRISBEE received from DIN {din}")
def nodeStateReceived(self, din):
print(f"[EVENT] Node state received from DIN {din}")
def atsSyncCompleted(self, din):
print(f"[EVENT] ATS sync completed with DIN {din}")
def frisbeeDperfCompleted(self, din, packets_sent, block_size):
print(
f"[EVENT] Frisbee DPERF completed: "
f"din={din}, packets={packets_sent}, block_size={block_size}"
)
def networkDiscovered(self, din, sid, link):
print(f"[EVENT] Network discovered: din={din}, sid={sid}, link={link}")
def nodeConnectedToNetwork(self, sid, din):
print(f"[EVENT] Node connected to network: sid={sid}, din={din}")
def streamInfoReceived(self, din, pkt_type, stream_id):
print(
f"[EVENT] Stream info: "
f"din={din}, pkt_type={pkt_type}, stream_id={stream_id}"
)
def check(node, err, label):
if err != pydaasiot.ERROR_NONE:
raise RuntimeError(f"{label} failed: {err} ({node.errorToString(err)})")
print(f"{label}: OK")
def main():
handler = MyHandler()
node = pydaasiot.DaasWrapper(None, handler)
check(node, node.doInit(SID, SENDER_DIN), "doInit")
check(node, node.enableDriver(pydaasiot._LINK_INET4, SENDER_URI), "enableDriver")
check(node, node.map(RECEIVER_DIN, pydaasiot._LINK_INET4, RECEIVER_URI), "map receiver")
check(node, node.doPerform(pydaasiot.PERFORM_CORE_THREAD), "doPerform")
time.sleep(1.0)
ddo = pydaasiot.DDO(1)
ddo.setPayload(b"Hello from sender!")
err = node.push(RECEIVER_DIN, ddo)
print(f"push result: {err} ({node.errorToString(err)})")
input("Press Enter to exit...\n")
node.doEnd()
if __name__ == "__main__":
main()
The full DaaS-IoT documentation — concepts, guides and the complete API — lives on the dedicated docs site.