Chapter 208: KNX/EIB Protocol Integration

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/uart.h"
#include "esp_log.h"

#define TPUART_NUM UART_NUM_2
#define TPUART_TXD_PIN 17
#define TPUART_RXD_PIN 16
#define TPUART_RTS_PIN UART_PIN_NO_CHANGE // Or your actual RTS pin if used
#define TPUART_CTS_PIN UART_PIN_NO_CHANGE // Or your actual CTS pin if used

#define BUF_SIZE 1024

static const char *TAG = "KNX_TPUART";

// Simplified structure for sending a KNX command via TPUART
// This structure and its framing are HIGHLY dependent on the specific TPUART module used.
// This is a generic representation.
typedef struct {
    uint16_t group_address; // Target group address
    uint8_t data_len;       // Payload length (e.g., 1 for DPT 1.001)
    uint8_t payload[16];    // Max payload size
} knx_tp_command_t;

// Initialize UART for TPUART communication
void tpuart_init() {
    uart_config_t uart_config = {
        .baud_rate = 19200,
        .data_bits = UART_DATA_8_BITS,
        .parity = UART_PARITY_EVEN, // Common for TPUART
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
        .source_clk = UART_SCLK_DEFAULT,
    };
    ESP_ERROR_CHECK(uart_driver_install(TPUART_NUM, BUF_SIZE * 2, 0, 0, NULL, 0));
    ESP_ERROR_CHECK(uart_param_config(TPUART_NUM, &uart_config));
    ESP_ERROR_CHECK(uart_set_pin(TPUART_NUM, TPUART_TXD_PIN, TPUART_RXD_PIN, TPUART_RTS_PIN, TPUART_CTS_PIN));
    ESP_LOGI(TAG, "TPUART initialized (TX: %d, RX: %d, Baud: %d 8E1)", TPUART_TXD_PIN, TPUART_RXD_PIN, uart_config.baud_rate);
}

// Send a command to the TPUART module
// Note: Actual framing (start bytes, checksums for serial link) depends on the TPUART module
void tpuart_send_knx_command(const knx_tp_command_t *cmd) {
    // Example: Send a "GroupValueWrite" for DPT 1.001 (On/Off)
    // The actual bytes sent to the TPUART will depend on its specific protocol.
    // This is a placeholder for the logic needed to frame the command for your TPUART.

    // Simplified representation:
    // Let's assume our TPUART expects:
    // <CMD_TYPE> <GA_HIGH> <GA_LOW> <LEN> <DATA_BYTE_0_WITH_APCI> ...
    // For GroupValueWrite (APCI = 0b10xxxxxx for write), DPT 1.001 (1 bit)
    // Data byte for ON: 0x81 (APCI for write + 1 bit data = 1)
    // Data byte for OFF: 0x80 (APCI for write + 1 bit data = 0)

    uint8_t tx_buffer[32];
    int tx_len = 0;

    // This is a conceptual framing. CONSULT YOUR TPUART DATASHEET.
    tx_buffer[tx_len++] = 0xBC; // Example: Some TPUARTs use a control byte or specific framing for commands
    tx_buffer[tx_len++] = (cmd->group_address >> 8) & 0xFF; // GA High
    tx_buffer[tx_len++] = cmd->group_address & 0xFF;        // GA Low
    tx_buffer[tx_len++] = cmd->data_len + 1; // Length of (APCI + Data). For 1 byte DPT, this would be 1.
                                          // For DPT 1.001, data_len is 1 (1 bit, but smallest unit is byte with APCI bits).
                                          // The APCI bits (e.g. for GroupValueWrite) are often combined with the first data byte.

    // For DPT 1.001, data_len would conceptually be 1 (for the single bit value).
    // The payload would contain the DPT value along with APCI bits.
    // Example: To send "ON" (value 1) to DPT 1.001 using GroupValueWrite
    // The actual payload byte might be 0b10000001 = 0x81 (assuming APCI for write is in upper bits)
    // For "OFF" (value 0), it might be 0b10000000 = 0x80
    memcpy(&tx_buffer[tx_len], cmd->payload, cmd->data_len);
    tx_len += cmd->data_len;

    // Add any other required framing bytes (e.g., checksum for UART link)
    // tx_buffer[tx_len++] = calculate_checksum(&tx_buffer[1], tx_len - 1); // Example

    int bytes_written = uart_write_bytes(TPUART_NUM, (const char *)tx_buffer, tx_len);
    if (bytes_written > 0) {
        ESP_LOGI(TAG, "Sent %d bytes to TPUART. GA: %04X, Payload[0]: %02X",
                 bytes_written, cmd->group_address, cmd->payload[0]);
    } else {
        ESP_LOGE(TAG, "Error sending data to TPUART");
    }
    // It's good practice to flush after writing, especially if not sending frequently
    uart_wait_tx_done(TPUART_NUM, pdMS_TO_TICKS(100));
}

// Task to listen for incoming data from TPUART
static void tpuart_rx_task(void *arg) {
    uint8_t *data = (uint8_t *) malloc(BUF_SIZE);
    while (1) {
        int len = uart_read_bytes(TPUART_NUM, data, BUF_SIZE -1 , pdMS_TO_TICKS(20)); // 20ms timeout
        if (len > 0) {
            data[len] = '\0'; // Null-terminate if expecting string-like data or for logging
            ESP_LOGI(TAG, "Received %d bytes from TPUART:", len);
            // Log as hex
            esp_log_buffer_hex(TAG, data, len);
            // Here you would parse the received TPUART frame according to its specification
            // to extract Source PA, Dest GA, DPT, and data.
            // Example: if (data[0] == KNX_TELEGRAM_INDICATOR_FROM_TPUART) { parse_knx_telegram(data, len); }
        }
        vTaskDelay(pdMS_TO_TICKS(10)); // Small delay to prevent busy-waiting if no data
    }
    free(data);
}


void app_main(void) {
    tpuart_init();
    xTaskCreate(tpuart_rx_task, "tpuart_rx_task", 2048, NULL, 10, NULL);

    vTaskDelay(pdMS_TO_TICKS(2000)); // Wait for UART to settle and RX task to start

    knx_tp_command_t cmd_light_on;
    cmd_light_on.group_address = 0x0101; // Example: Group Address 1/1/1
    cmd_light_on.data_len = 1;           // For DPT 1.001, payload is 1 byte (6 bits for APCI, 1 bit for data)
    cmd_light_on.payload[0] = 0x81;      // DPT 1.001 "ON" (0b10000001 -> APCI for write = 0b10xxxxxx, data bit = 1)

    ESP_LOGI(TAG, "Sending KNX command: Light ON to GA %04X", cmd_light_on.group_address);
    tpuart_send_knx_command(&cmd_light_on);

    vTaskDelay(pdMS_TO_TICKS(5000));

    knx_tp_command_t cmd_light_off;
    cmd_light_off.group_address = 0x0101; // Example: Group Address 1/1/1
    cmd_light_off.data_len = 1;
    cmd_light_off.payload[0] = 0x80;     // DPT 1.001 "OFF" (0b10000000 -> APCI for write = 0b10xxxxxx, data bit = 0)

    ESP_LOGI(TAG, "Sending KNX command: Light OFF to GA %04X", cmd_light_off.group_address);
    tpuart_send_knx_command(&cmd_light_off);
}

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "esp_system.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_log.h"
#include "nvs_flash.h"

#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include <lwip/netdb.h>

// Wi-Fi Configuration
#define WIFI_SSID      "YOUR_WIFI_SSID"
#define WIFI_PASS      "YOUR_WIFI_PASSWORD"
#define MAX_WIFI_RETRY 10

// KNX IP Configuration
#define KNX_IP_ROUTER_ADDR "192.168.1.100" // Replace with your KNX IP Router/Interface IP
#define KNX_IP_PORT        3671

static const char *TAG = "KNX_IP";
static EventGroupHandle_t s_wifi_event_group;
#define WIFI_CONNECTED_BIT BIT0
#define WIFI_FAIL_BIT      BIT1
static int s_retry_num = 0;

// KNXnet/IP Core Service Identifiers
#define KNXNETIP_CORE_SEARCH_REQUEST        0x0201
#define KNXNETIP_CORE_SEARCH_RESPONSE       0x0202
#define KNXNETIP_CORE_DESCRIPTION_REQUEST   0x0203
#define KNXNETIP_CORE_DESCRIPTION_RESPONSE  0x0204
#define KNXNETIP_CORE_CONNECT_REQUEST       0x0205
#define KNXNETIP_CORE_CONNECT_RESPONSE      0x0206
#define KNXNETIP_CORE_CONNECTIONSTATE_REQUEST 0x0207
#define KNXNETIP_CORE_CONNECTIONSTATE_RESPONSE 0x0208
#define KNXNETIP_CORE_DISCONNECT_REQUEST    0x0209
#define KNXNETIP_CORE_DISCONNECT_RESPONSE   0x020A

// KNXnet/IP Tunneling Service Identifiers
#define KNXNETIP_TUNNEL_TUNNELLING_REQUEST  0x0420
#define KNXNETIP_TUNNEL_TUNNELLING_ACK      0x0421

// KNXnet/IP Header Structure (simplified)
typedef struct {
    uint8_t header_len;         // 0x06 for core services
    uint8_t protocol_version;   // 0x10 (KNXnet/IP v1.0)
    uint16_t service_type_id;   // e.g., CONNECT_REQUEST
    uint16_t total_len;         // Total length of the frame (header + body)
} knx_ip_header_t;

// KNXnet/IP Connect Request Body (Control Endpoint + Data Endpoint)
typedef struct {
    uint8_t structure_len_hpai_ctrl; // 0x08
    uint8_t host_protocol_code_ctrl; // 0x01 (UDP)
    uint8_t ip_addr_ctrl[4];         // 0.0.0.0 (don't care for control endpoint on client)
    uint16_t port_ctrl;              // 0 (don't care for control endpoint on client)
    uint8_t structure_len_hpai_data; // 0x08
    uint8_t host_protocol_code_data; // 0x01 (UDP)
    uint8_t ip_addr_data[4];         // 0.0.0.0 (don't care for data endpoint on client)
    uint16_t port_data;              // 0 (don't care for data endpoint on client)
    uint8_t structure_len_cri;       // 0x04
    uint8_t connection_type_code;    // 0x04 (Tunneling Connection)
    uint8_t knx_layer;               // 0x02 (Tunneling on bus link layer)
    uint8_t reserved;                // 0x00
} knx_ip_connect_request_body_t;

// KNXnet/IP Connect Response (simplified)
typedef struct {
    uint8_t channel_id;
    uint8_t status;
    // ... other fields (HPAI, CRI data)
} knx_ip_connect_response_data_t; // This is a partial representation

// KNX cEMI frame for Tunneling Request (L_Data.req)
// This is a simplified version for GroupValueWrite, DPT 1.001
typedef struct {
    uint8_t message_code;       // 0x11 for L_Data.req
    uint8_t add_info_len;       // 0x00
    uint8_t control_field_1;    // e.g., 0xBC (standard frame, normal prio, repeat ok)
    uint8_t control_field_2;    // e.g., 0xE0 (destination is group addr, hop count 6)
    uint16_t source_addr;       // 0x0000 (KNX IP router will fill this, or a configured PA)
    uint16_t dest_group_addr;   // Target Group Address
    uint8_t data_len_apci;      // Length of APCI + PDU (e.g., 1 for DPT 1.001)
    uint8_t apci_data;          // APCI (e.g., 0x80 for GroupValueWrite) + Data (e.g., 0/1)
} knx_cemi_l_data_req_t;


// KNXnet/IP Tunneling Request Header (prepended to cEMI)
typedef struct {
    uint8_t structure_len;      // 0x04
    uint8_t channel_id;
    uint8_t seq_counter;
    uint8_t reserved;           // 0x00
} knx_tunnel_header_t;


static void wifi_event_handler(void* arg, esp_event_base_t event_base,
                               int32_t event_id, void* event_data) {
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        esp_wifi_connect();
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        if (s_retry_num < MAX_WIFI_RETRY) {
            esp_wifi_connect();
            s_retry_num++;
            ESP_LOGI(TAG, "Retrying to connect to the AP");
        } else {
            xEventGroupSetBits(s_wifi_event_group, WIFI_FAIL_BIT);
        }
        ESP_LOGI(TAG,"Connect to the AP fail");
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "Got IP: " IPSTR, IP2STR(&event->ip_info.ip));
        s_retry_num = 0;
        xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
    }
}

void wifi_init_sta(void) {
    s_wifi_event_group = xEventGroupCreate();

    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    esp_netif_create_default_wifi_sta();

    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));

    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
                                                        ESP_EVENT_ANY_ID,
                                                        &wifi_event_handler,
                                                        NULL,
                                                        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
                                                        IP_EVENT_STA_GOT_IP,
                                                        &wifi_event_handler,
                                                        NULL,
                                                        &instance_got_ip));

    wifi_config_t wifi_config = {
        .sta = {
            .ssid = WIFI_SSID,
            .password = WIFI_PASS,
            .threshold.authmode = WIFI_AUTH_WPA2_PSK, // Adjust as needed
        },
    };
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config) );
    ESP_ERROR_CHECK(esp_wifi_start() );

    ESP_LOGI(TAG, "wifi_init_sta finished.");

    EventBits_t bits = xEventGroupWaitBits(s_wifi_event_group,
            WIFI_CONNECTED_BIT | WIFI_FAIL_BIT,
            pdFALSE,
            pdFALSE,
            portMAX_DELAY);

    if (bits & WIFI_CONNECTED_BIT) {
        ESP_LOGI(TAG, "Connected to AP SSID:%s", WIFI_SSID);
    } else if (bits & WIFI_FAIL_BIT) {
        ESP_LOGI(TAG, "Failed to connect to SSID:%s", WIFI_SSID);
    } else {
        ESP_LOGE(TAG, "UNEXPECTED EVENT");
    }
}

static void knx_ip_task(void *pvParameters) {
    char rx_buffer[128];
    char tx_buffer[128];
    int sock = -1;
    uint8_t knx_channel_id = 0;
    uint8_t knx_seq_counter = 0; // Must be incremented for each Tunneling Request


    // Wait for Wi-Fi connection
    xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
    ESP_LOGI(TAG, "Wi-Fi Connected. Starting KNX IP Task.");

    struct sockaddr_in dest_addr;
    dest_addr.sin_addr.s_addr = inet_addr(KNX_IP_ROUTER_ADDR);
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(KNX_IP_PORT);

    sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
    if (sock < 0) {
        ESP_LOGE(TAG, "Unable to create socket: errno %d", errno);
        goto knx_fail;
    }
    ESP_LOGI(TAG, "Socket created, connecting to %s:%d", KNX_IP_ROUTER_ADDR, KNX_IP_PORT);

    // 1. Send CONNECT_REQUEST
    knx_ip_header_t *hdr = (knx_ip_header_t *)tx_buffer;
    hdr->header_len = 0x06;
    hdr->protocol_version = 0x10;
    hdr->service_type_id = htons(KNXNETIP_CORE_CONNECT_REQUEST); // Big Endian

    knx_ip_connect_request_body_t *connect_req_body = (knx_ip_connect_request_body_t *)(tx_buffer + sizeof(knx_ip_header_t));
    // Control Endpoint HPAI (client can leave it 0.0.0.0:0)
    connect_req_body->structure_len_hpai_ctrl = 0x08;
    connect_req_body->host_protocol_code_ctrl = 0x01; // UDP
    memset(connect_req_body->ip_addr_ctrl, 0, 4);
    connect_req_body->port_ctrl = 0;
    // Data Endpoint HPAI (client can leave it 0.0.0.0:0)
    connect_req_body->structure_len_hpai_data = 0x08;
    connect_req_body->host_protocol_code_data = 0x01; // UDP
    memset(connect_req_body->ip_addr_data, 0, 4);
    connect_req_body->port_data = 0;
    // Connection Request Information (CRI)
    connect_req_body->structure_len_cri = 0x04;
    connect_req_body->connection_type_code = 0x04; // Tunneling
    connect_req_body->knx_layer = 0x02; // Busmon not supported, use Link Layer tunneling
    connect_req_body->reserved = 0x00;

    hdr->total_len = htons(sizeof(knx_ip_header_t) + sizeof(knx_ip_connect_request_body_t));

    int err = sendto(sock, tx_buffer, sizeof(knx_ip_header_t) + sizeof(knx_ip_connect_request_body_t), 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
    if (err < 0) {
        ESP_LOGE(TAG, "Error occurred during sending CONNECT_REQUEST: errno %d", errno);
        goto knx_fail;
    }
    ESP_LOGI(TAG, "CONNECT_REQUEST sent");

    // 2. Receive CONNECT_RESPONSE
    struct sockaddr_storage source_addr;
    socklen_t socklen = sizeof(source_addr);
    int len = recvfrom(sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&source_addr, &socklen);

    if (len < 0) {
        ESP_LOGE(TAG, "recvfrom failed for CONNECT_RESPONSE: errno %d", errno);
        goto knx_fail;
    } else {
        ESP_LOGI(TAG, "Received %d bytes for CONNECT_RESPONSE", len);
        knx_ip_header_t *resp_hdr = (knx_ip_header_t *)rx_buffer;
        if (ntohs(resp_hdr->service_type_id) == KNXNETIP_CORE_CONNECT_RESPONSE) {
            knx_ip_connect_response_data_t *resp_data = (knx_ip_connect_response_data_t *)(rx_buffer + sizeof(knx_ip_header_t));
            if (resp_data->status == 0x00) { // E_NO_ERROR
                knx_channel_id = resp_data->channel_id;
                ESP_LOGI(TAG, "KNX IP Connection successful. Channel ID: %d", knx_channel_id);

                // Now we have a channel, let's send a TUNNELLING_REQUEST (e.g., GroupValueWrite)
                vTaskDelay(pdMS_TO_TICKS(1000)); // Wait a bit

                knx_ip_header_t *tunnel_hdr = (knx_ip_header_t *)tx_buffer;
                tunnel_hdr->header_len = 0x06;
                tunnel_hdr->protocol_version = 0x10;
                tunnel_hdr->service_type_id = htons(KNXNETIP_TUNNEL_TUNNELLING_REQUEST);

                knx_tunnel_header_t *tunnel_sub_hdr = (knx_tunnel_header_t *)(tx_buffer + sizeof(knx_ip_header_t));
                tunnel_sub_hdr->structure_len = 0x04;
                tunnel_sub_hdr->channel_id = knx_channel_id;
                tunnel_sub_hdr->seq_counter = knx_seq_counter++; // Use and increment
                tunnel_sub_hdr->reserved = 0x00;

                knx_cemi_l_data_req_t *cemi = (knx_cemi_l_data_req_t *)(tx_buffer + sizeof(knx_ip_header_t) + sizeof(knx_tunnel_header_t));
                cemi->message_code = 0x11; // L_Data.req
                cemi->add_info_len = 0x00;
                cemi->control_field_1 = 0xBC; // Standard frame, priority system, ACK request
                cemi->control_field_2 = 0xE0; // Dest is Group Addr, Hop Count 6 (standard)
                cemi->source_addr = htons(0x0000); // Or your device's PA if configured & known
                cemi->dest_group_addr = htons(0x0101); // Target GA 1/1/1 (format: Main(5bit)/Sub(11bit) -> 00001 00000010001 = 0x0901 or use 2-level: 0001 00000001 -> 0x0101 )
                                                     // For 3-level 1/1/1: (1<<11) | (1<<8) | 1 = 0x0901
                                                     // For 2-level Main/Sub (as used in example 1, 0x0101): if main_group=1, sub_group=1 -> (1<<8)|1 = 257 = 0x0101.
                                                     // Ensure format matches ETS project! Assuming 0x0101 means Main=1, Sub=1 (using 2-level interpretation here for simplicity)

                cemi->data_len_apci = 1;    // Length of (APCI + Data payload). For DPT 1.001, 1 byte.
                cemi->apci_data = 0x81;     // GroupValueWrite (APCI bits 10xx xxxx) + Data 1 (ON)
                                            // Lower 6 bits of APCI for DPT 1.001 are 000000.
                                            // APCI Command: 0b10 (GroupValueWrite) -> shifted (value << 2) becomes 0b10000000 = 0x80
                                            // Data: 0x01 (ON) -> combined 0x80 | 0x01 = 0x81

                uint16_t total_tunnel_len = sizeof(knx_ip_header_t) + sizeof(knx_tunnel_header_t) + sizeof(knx_cemi_l_data_req_t);
                tunnel_hdr->total_len = htons(total_tunnel_len);

                err = sendto(sock, tx_buffer, total_tunnel_len, 0, (struct sockaddr *)&dest_addr, sizeof(dest_addr));
                if (err < 0) {
                    ESP_LOGE(TAG, "Error occurred during sending TUNNELLING_REQUEST: errno %d", errno);
                } else {
                    ESP_LOGI(TAG, "TUNNELLING_REQUEST sent (Light ON to GA %04X). Seq: %d", ntohs(cemi->dest_group_addr), tunnel_sub_hdr->seq_counter -1);

                    // Wait for TUNNELLING_ACK
                    len = recvfrom(sock, rx_buffer, sizeof(rx_buffer) - 1, 0, (struct sockaddr *)&source_addr, &socklen);
                    if (len > 0) {
                        knx_ip_header_t *ack_hdr = (knx_ip_header_t *)rx_buffer;
                        if (ntohs(ack_hdr->service_type_id) == KNXNETIP_TUNNEL_TUNNELLING_ACK) {
                           knx_tunnel_header_t *ack_tunnel_hdr = (knx_tunnel_header_t *)(rx_buffer + sizeof(knx_ip_header_t));
                           // Check ack_tunnel_hdr->channel_id and ack_tunnel_hdr->seq_counter
                           // And status byte which is rx_buffer[sizeof(knx_ip_header_t) + sizeof(knx_tunnel_header_t)]
                           uint8_t ack_status = rx_buffer[sizeof(knx_ip_header_t) + sizeof(knx_tunnel_header_t)];
                           ESP_LOGI(TAG, "TUNNELLING_ACK received. Seq: %d, Status: %02X", ack_tunnel_hdr->seq_counter, ack_status);
                        } else {
                           ESP_LOGW(TAG, "Received unexpected KNX IP packet instead of ACK. Service: 0x%04X", ntohs(ack_hdr->service_type_id));
                        }
                    } else {
                        ESP_LOGE(TAG, "Error receiving TUNNELLING_ACK");
                    }
                }
                // Implement heartbeat (CONNECTIONSTATE_REQUEST) and disconnect logic here for robust app
            } else {
                ESP_LOGE(TAG, "KNX IP Connection failed. Status: %02X", resp_data->status);
            }
        } else {
            ESP_LOGE(TAG, "Received unexpected KNX IP packet. Service Type: 0x%04X", ntohs(resp_hdr->service_type_id));
        }
    }

knx_fail:
    if (sock != -1) {
        // Send DISCONNECT_REQUEST (important for releasing resources on the KNX IP router)
        // Similar structure to CONNECT_REQUEST but with DISCONNECT_REQUEST service type
        // and using the obtained knx_channel_id.
        ESP_LOGI(TAG, "Shutting down socket and cleaning up...");
        shutdown(sock, 0);
        close(sock);
    }
    vTaskDelete(NULL);
}

void app_main(void) {
    // Initialize NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
      ESP_ERROR_CHECK(nvs_flash_erase());
      ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    ESP_LOGI(TAG, "ESP_WIFI_MODE_STA");
    wifi_init_sta();

    xTaskCreate(knx_ip_task, "knx_ip_task", 4096, NULL, 5, NULL);
}

CONFIG_ESP_WIFI_SSID="YOUR_WIFI_SSID"
CONFIG_ESP_WIFI_PASSWORD="YOUR_WIFI_PASSWORD"
CONFIG_ESP_MAXIMUM_RETRY=10
# Ensure LWIP options are enabled (usually by default)
# Ensure TCP/IP Adapter is enabled