KNXnet/IP Tunnelling

using var udp = new UdpClient(0);
int localPort = ((IPEndPoint)udp.Client.LocalEndPoint).Port;
string localIp = "192.168.178.23"; // deine lokale IP im selben Subnetz

byte[] hpai = BuildHpai(localIp, localPort);   // 08 01 + IP(4) + Port(2)
byte[] cri  = { 0x04, 0x04, 0x02, 0x00 }; // TUNNEL_CONNECTION, TUNNEL_LINKLAYER
byte[] header = BuildHeader(0x0205, hpai.Length * 2 + cri.Length);

byte[] request = Concat(header, hpai, hpai, cri);
udp.Send(request, request.Length, new IPEndPoint(IPAddress.Parse("192.168.178.42"), 3671));

byte[] response = udp.Receive(ref IPEndPoint.Any); // CONNECT_RESPONSE
byte channelId = response[6];
byte status    = response[7]; // 0x00 = OK

// DPT1 (1 Bit, z.B. Schalten) - Wert steckt im APCI Byte selbst
byte[] cemi = {
    0x11, 0x00, 0xBC, 0xE0,       // L_Data.req, Control1, Control2
    0x00, 0x00,                   // Quelladresse (vom Gateway gesetzt)
    0x08, 0x00,                   // Ziel: Gruppenadresse 1/0/0
    0x01, 0x00,                   // NPDU-Länge, TPCI
    (byte)(0x80 | (value ? 1 : 0)) // APCI GroupValueWrite + 1-Bit-Wert
};

byte[] connHeader = { 0x04, channelId, sequenceCounter, 0x00 };
byte[] header     = BuildHeader(0x0420, connHeader.Length + cemi.Length);
byte[] request    = Concat(header, connHeader, cemi);

udp.Send(request, request.Length, gatewayEndpoint);
// -> auf TUNNELING_ACK warten (Service Type 0x0421), sequenceCounter danach +1

static byte[] EncodeDpt9(double value)
{
    double m = value * 100.0;
    int exponent = 0;
    while (m < -2048.0 || m > 2047.0) { m /= 2.0; exponent++; }

    int mantissa = (int)Math.Round(m);
    int sign = mantissa < 0 ? 1 : 0;
    int raw = (sign << 15) | (exponent << 11) | (mantissa & 0x7FF);
    return new[] { (byte)(raw >> 8), (byte)(raw & 0xFF) };
}

static double DecodeDpt9(byte[] data)
{
    int raw = (data[0] << 8) | data[1];
    bool negative = (raw & 0x8000) != 0;   // eigenes Sign-Bit, nicht raten!
    int exponent = (raw >> 11) & 0x0F;
    int mantissa = raw & 0x7FF;
    if (negative) mantissa -= 2048;
    return 0.01 * mantissa * Math.Pow(2, exponent);
}

while (listening)
{
    byte[] data = udp.Receive(ref remoteEP);
    ushort serviceType = (ushort)((data[2] << 8) | data[3]);

    if (serviceType == 0x0420) // TUNNELING_REQUEST vom Gateway
    {
        byte seqCounter = data[8];
        SendTunnelingAck(seqCounter);   // Pflicht: sofort bestätigen

        byte[] cemi = data[10..];
        if (cemi[0] == 0x29) // L_Data.ind - echtes Bus-Telegramm
            HandleIncomingTelegram(cemi);
    }
}

using System.Net;
using System.Net.Sockets;

class Program
{
    static UdpClient?  udp;
    static IPEndPoint? gatewayEndPoint;
    static string      localIp = "";
    static int         localPort;
    static byte        channelId;

    static void Main()
    {
        Print(ConsoleColor.Cyan, "==========================================================================\n" +
                               "                     KNX IP Gateway - DPT1 Sender\n" +
                               "==========================================================================\n");

        Console.ForegroundColor = ConsoleColor.Yellow;
        Console.Write("IP Adresse des KNX IP Gateways (Enter = 192.168.178.42): ");
        Console.ForegroundColor = ConsoleColor.White;
        string? ipInput = Console.ReadLine();
        string ip = string.IsNullOrWhiteSpace(ipInput) ? "192.168.178.42" : ipInput.Trim();

        string groupAddress;
        while (true)
        {
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write("Gruppenadresse (Enter = 1/0/0): ");
            Console.ForegroundColor = ConsoleColor.White;
            string? input = Console.ReadLine();

            if (string.IsNullOrWhiteSpace(input)) { groupAddress = "1/0/0"; break; }

            string[] parts = input.Trim().Split('/');
            if (parts.Length == 3 && int.TryParse(parts[0], out _) && int.TryParse(parts[1], out _) && int.TryParse(parts[2], out _))
            { groupAddress = input.Trim(); break; }

            Print(ConsoleColor.Red, "[!] Ungueltiges Format - bitte als Haupt/Mittel/Unter eingeben, z.B. 1/0/0");
        }

        bool value;
        while (true)
        {
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write("Wert senden - true oder false: ");
            Console.ForegroundColor = ConsoleColor.White;
            string? input = Console.ReadLine()?.Trim().ToLower();

            if (input == "true") { value = true; break; }
            if (input == "false") { value = false; break; }

            Print(ConsoleColor.Red, "[!] Bitte genau \"true\" oder \"false\" eingeben.");
        }

        Console.WriteLine();
        Connect(ip);
        SendDpt1(groupAddress, value);
        Disconnect();

        Console.WriteLine();
        Print(ConsoleColor.Cyan, "Fertig. Enter zum Beenden...");
        Console.ReadLine();
        Console.ResetColor();
    }

    static void Print(ConsoleColor color, string text)
    {
        Console.ForegroundColor = color;
        Console.WriteLine(text);
        Console.ResetColor();
    }

    static void Connect(string ip)
    {
        Print(ConsoleColor.Cyan, $"Verbinde zu {ip}:3671 ...");

        gatewayEndPoint = new IPEndPoint(IPAddress.Parse(ip), 3671);
        udp = new UdpClient(0) { Client = { ReceiveTimeout = 3000 } };
        localPort = ((IPEndPoint)udp.Client.LocalEndPoint).Port;

        using (var s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, 0))
        {
            s.Connect(ip, 3671);
            localIp = ((IPEndPoint)s.LocalEndPoint).Address.ToString();
        }

        byte[] hpai = BuildHpai(localIp, localPort);
        byte[] cri = { 0x04, 0x04, 0x02, 0x00 };
        byte[] request = Concat(BuildHeader(0x0205, hpai.Length * 2 + cri.Length), hpai, hpai, cri);
        udp.Send(request, request.Length, gatewayEndPoint);

        byte[] response;
        try { IPEndPoint ep = new IPEndPoint(IPAddress.Any, 0); response = udp.Receive(ref ep); }
        catch (SocketException) { Print(ConsoleColor.Red, "[!] Keine Antwort vom Gateway."); return; }

        if (response.Length < 8 || response[2] != 0x02 || response[3] != 0x06 || response[7] != 0x00)
        { Print(ConsoleColor.Red, "[!] Verbindung abgelehnt."); return; }

        channelId = response[6];
        Print(ConsoleColor.Green, $"Verbunden. Channel ID: {channelId}");
    }

    static void SendDpt1(string groupAddress, bool value)
    {
        if (udp == null || gatewayEndPoint == null) { Print(ConsoleColor.Red, "[!] Nicht verbunden - kann nicht senden."); return; }

        Print(ConsoleColor.Cyan, $"Sende {groupAddress} = {value} ...");

        string[] parts = groupAddress.Split('/');
        int main = int.Parse(parts[0]), middle = int.Parse(parts[1]), sub = int.Parse(parts[2]);
        ushort ga = (ushort)(((main & 0x1F) << 11) | ((middle & 0x07) << 8) | (sub & 0xFF));

        byte[] cemi =
        {
            0x11, 0x00, 0xBC, 0xE0,
            0x00, 0x00,
            (byte)(ga >> 8), (byte)(ga & 0xFF),
            0x01, 0x00,
            (byte)(0x80 | (value ? 0x01 : 0x00))
        };

        byte[] connHeader = { 0x04, channelId, 0x00, 0x00 };
        byte[] request = Concat(BuildHeader(0x0420, connHeader.Length + cemi.Length), connHeader, cemi);
        udp.Send(request, request.Length, gatewayEndPoint);

        byte[] response;
        try { IPEndPoint ep = new IPEndPoint(IPAddress.Any, 0); response = udp.Receive(ref ep); }
        catch (SocketException) { Print(ConsoleColor.Red, "[!] Kein ACK erhalten."); return; }

        bool ok = response.Length >= 6 && response[2] == 0x04 && response[3] == 0x21;
        Print(ok ? ConsoleColor.Green : ConsoleColor.Red, ok ? $"{groupAddress} = {value} gesendet und bestaetigt." : "[!] Kein ACK erhalten.");
    }

    static void Disconnect()
    {
        if (udp == null || gatewayEndPoint == null) return;

        byte[] hpai = BuildHpai(localIp, localPort);
        byte[] body = Concat(new byte[] { channelId, 0x00 }, hpai);
        byte[] request = Concat(BuildHeader(0x0209, body.Length), body);
        udp.Send(request, request.Length, gatewayEndPoint);

        try { IPEndPoint ep = new IPEndPoint(IPAddress.Any, 0); udp.Receive(ref ep); }
        catch (SocketException) { /* keine Antwort ist unkritisch */ }

        udp.Dispose();
        Print(ConsoleColor.Cyan, "Verbindung getrennt.");
    }

    static byte[] BuildHeader(ushort serviceType, int bodyLength)
    {
        int totalLength = 6 + bodyLength;
        return new byte[] { 0x06, 0x10, (byte)(serviceType >> 8), (byte)(serviceType & 0xFF), (byte)(totalLength >> 8), (byte)(totalLength & 0xFF) };
    }

    static byte[] BuildHpai(string ip, int port)
    {
        byte[] ipBytes = IPAddress.Parse(ip).GetAddressBytes();
        return new byte[] { 0x08, 0x01, ipBytes[0], ipBytes[1], ipBytes[2], ipBytes[3], (byte)(port >> 8), (byte)(port & 0xFF) };
    }

    static byte[] Concat(params byte[][] arrays)
    {
        byte[] result = new byte[arrays.Sum(a => a.Length)];
        int offset = 0;
        foreach (var a in arrays) { Buffer.BlockCopy(a, 0, result, offset, a.Length); offset += a.Length; }
        return result;
    }
}