KNXnet/IP quickstart

import asyncio
from knxyz import discover_gateways

async def main():
    gateways = await discover_gateways(timeout_ms=1500)
    for gateway in gateways:
        print(gateway["controlEndpoint"])

asyncio.run(main())

import { discoverGateways } from "@knxyz/knx";

const gateways = await discoverGateways({ timeoutMs: 1500 });
for (const gateway of gateways) {
  console.log(gateway.controlEndpoint);
}

use knxyz::ip::{discover_gateways, DiscoveryOptions};

let gateways = discover_gateways(DiscoveryOptions::default()).await?;
for gateway in gateways {
    println!("{}", gateway.control_endpoint);
}

import asyncio
from knxyz import connect_tunnel

async def main():
    client = await connect_tunnel(host="192.0.2.10")
    try:
        print("connected")
    finally:
        await client.close()

asyncio.run(main())

import { connectTunnel } from "@knxyz/knx";

const client = await connectTunnel({ host: "192.0.2.10" });
try {
  console.log("connected");
} finally {
  await client.close();
}

use knxyz::ip::TunnelClient;
use std::net::ToSocketAddrs;

let gateway = "192.0.2.10:3671"
    .to_socket_addrs()?
    .next()
    .expect("gateway address");
let mut client = TunnelClient::connect(gateway).await?;
client.disconnect().await?;

value = await client.read("1/0/0", "9.001")
print(value)

const value = await client.read("1/0/0", "9.001");
console.log(value);

use knxyz::GroupAddress;
use std::time::Duration;

let group = "1/0/0".parse::<GroupAddress>()?;
let value = client
    .group_read(group, "9.001", Duration::from_secs(3))
    .await?;
println!("{value:?}");

await client.write("1/2/3", True, "1.001")

await client.write("1/2/3", true, "1.001");

use knxyz::{DptValue, GroupAddress};

let group = "1/2/3".parse::<GroupAddress>()?;
client
    .group_write(group, DptValue::Bool(true))
    .await?;