Ejemplo n.º 1
0
def build_and_destroy_tunnel(xknx):

    gatewayscanner = GatewayScanner(xknx)
    yield from gatewayscanner.async_start()

    if not gatewayscanner.found:
        print("No Gateways found")
        return

    src_address = Address("15.15.249")

    print("Connecting to {}:{} from {}".format(gatewayscanner.found_ip_addr,
                                               gatewayscanner.found_port,
                                               gatewayscanner.found_local_ip))

    tunnel = Tunnel(xknx,
                    src_address,
                    local_ip=gatewayscanner.found_local_ip,
                    gateway_ip=gatewayscanner.found_ip_addr,
                    gateway_port=gatewayscanner.found_port)

    yield from tunnel.connect_udp()
    yield from tunnel.connect()

    yield from tunnel.send_telegram(
        Telegram(Address('1/0/15'), payload=DPTBinary(0)))
    yield from asyncio.sleep(2)
    yield from tunnel.send_telegram(
        Telegram(Address('1/0/15'), payload=DPTBinary(1)))
    yield from asyncio.sleep(2)

    yield from tunnel.connectionstate()
    yield from tunnel.disconnect()
Ejemplo n.º 2
0
async def main():
    """Connect to a tunnel, send 2 telegrams and disconnect."""
    xknx = XKNX()
    gatewayscanner = GatewayScanner(xknx)
    gateways = await gatewayscanner.scan()

    if not gateways:
        print("No Gateways found")
        return

    gateway = gateways[0]
    src_address = PhysicalAddress("15.15.249")

    print("Connecting to {}:{} from {}".format(gateway.ip_addr, gateway.port,
                                               gateway.local_ip))

    tunnel = Tunnel(xknx,
                    src_address,
                    local_ip=gateway.local_ip,
                    gateway_ip=gateway.ip_addr,
                    gateway_port=gateway.port)

    await tunnel.connect_udp()
    await tunnel.connect()

    await tunnel.send_telegram(
        Telegram(GroupAddress('1/0/15'), payload=DPTBinary(1)))
    await asyncio.sleep(2)
    await tunnel.send_telegram(
        Telegram(GroupAddress('1/0/15'), payload=DPTBinary(0)))
    await asyncio.sleep(2)

    await tunnel.connectionstate()
    await tunnel.disconnect()
Ejemplo n.º 3
0
 def setUp(self):
     """Set up test class."""
     self.loop = asyncio.new_event_loop()
     asyncio.set_event_loop(self.loop)
     self.xknx = XKNX()
     self.tg_received_mock = Mock()
     self.tunnel = Tunnel(
         self.xknx,
         local_ip="192.168.1.1",
         gateway_ip="192.168.1.2",
         gateway_port=3671,
         telegram_received_callback=self.tg_received_mock,
         auto_reconnect=False,
         auto_reconnect_wait=3,
     )
Ejemplo n.º 4
0
 def setup_method(self):
     """Set up test class."""
     # pylint: disable=attribute-defined-outside-init
     self.xknx = XKNX()
     self.tg_received_mock = Mock()
     self.tunnel = Tunnel(
         self.xknx,
         gateway_ip="192.168.1.2",
         gateway_port=3671,
         local_ip="192.168.1.1",
         local_port=0,
         telegram_received_callback=self.tg_received_mock,
         auto_reconnect=False,
         auto_reconnect_wait=3,
         route_back=False,
     )
Ejemplo n.º 5
0
async def main():
    """Connect to a tunnel, send 2 telegrams and disconnect."""
    xknx = XKNX()
    gatewayscanner = GatewayScanner(xknx)
    gateways = await gatewayscanner.scan()

    if not gateways:
        print("No Gateways found")
        return

    gateway = gateways[0]
    # an individual address will most likely be assigned by the tunnelling server
    xknx.own_address = IndividualAddress("15.15.249")

    print(f"Connecting to {gateway.ip_addr}:{gateway.port} from {gateway.local_ip}")

    tunnel = Tunnel(
        xknx,
        gateway_ip=gateway.ip_addr,
        gateway_port=gateway.port,
        local_ip=gateway.local_ip,
        local_port=0,
        route_back=False,
    )

    await tunnel.connect()

    await tunnel.send_telegram(
        Telegram(
            destination_address=GroupAddress("1/0/15"),
            payload=GroupValueWrite(DPTBinary(1)),
        )
    )
    await asyncio.sleep(2)
    await tunnel.send_telegram(
        Telegram(
            destination_address=GroupAddress("1/0/15"),
            payload=GroupValueWrite(DPTBinary(0)),
        )
    )
    await asyncio.sleep(2)

    await tunnel.disconnect()
Ejemplo n.º 6
0
async def main():
    """Connect to a tunnel, send 2 telegrams and disconnect."""
    xknx = XKNX()
    gatewayscanner = GatewayScanner(xknx)
    gateways = await gatewayscanner.scan()

    if not gateways:
        print("No Gateways found")
        return

    gateway = gateways[0]
    # an individual address will most likely be assigned by the tunnelling server
    xknx.own_address = PhysicalAddress("15.15.249")

    print("Connecting to {}:{} from {}".format(gateway.ip_addr, gateway.port,
                                               gateway.local_ip))

    tunnel = Tunnel(
        xknx,
        local_ip=gateway.local_ip,
        gateway_ip=gateway.ip_addr,
        gateway_port=gateway.port,
    )

    await tunnel.connect_udp()
    await tunnel.connect()

    await tunnel.send_telegram(
        Telegram(GroupAddress("1/0/15"), payload=DPTBinary(1)))
    await asyncio.sleep(2)
    await tunnel.send_telegram(
        Telegram(GroupAddress("1/0/15"), payload=DPTBinary(0)))
    await asyncio.sleep(2)

    await tunnel.connectionstate()
    await tunnel.disconnect()