ioLibrary Driver

https://github.com/wiznet/iolibrary_driver
Admin
ioLibrary Driver is a TCP/IP driver library with Berkeley Socket APIs and application protocols for...
Tokens:20,050
Snippets:70
Trust Score:9.5
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Initialize WIZnet Chip with Custom Buffers

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initializes the WIZnet chip with custom TX and RX buffer allocations per socket. This example allocates 8KB for socket 0 and 2KB for sockets 1-3, with smaller allocations for subsequent sockets.

```c
#include "wizchip_conf.h"

// Example with unequal buffer allocation
void initialize_wizchip_custom(void) {
    // Socket 0: 8KB TX/RX for high-throughput connection
    // Other sockets: 2KB each
    uint8_t tx_buf_sizes[8] = {8, 2, 2, 2, 1, 1, 0, 0};
    uint8_t rx_buf_sizes[8] = {8, 2, 2, 2, 1, 1, 0, 0};

    wizchip_init(tx_buf_sizes, rx_buf_sizes);
}
```

--------------------------------

### Configure and Get Network Information

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Use wizchip_setnetinfo to configure static network parameters like MAC, IP, subnet, gateway, and DNS. wizchip_getnetinfo retrieves the current network configuration.

```c
#include "wizchip_conf.h"

void configure_network(void) {
    wiz_NetInfo netinfo = {
        .mac  = {0x00, 0x08, 0xDC, 0x12, 0x34, 0x56},
        .ip   = {192, 168, 1, 10},
        .sn   = {255, 255, 255, 0},
        .gw   = {192, 168, 1, 1},
        .dns  = {8, 8, 8, 8},
        .dhcp = NETINFO_STATIC
    };

    // Set network configuration
    wizchip_setnetinfo(&netinfo);
    printf("Network configured: IP %d.%d.%d.%d\n",
           netinfo.ip[0], netinfo.ip[1], netinfo.ip[2], netinfo.ip[3]);
}

void print_network_info(void) {
    wiz_NetInfo netinfo;

    // Get current network configuration
    wizchip_getnetinfo(&netinfo);

    printf("MAC: %02X:%02X:%02X:%02X:%02X:%02X\n",
           netinfo.mac[0], netinfo.mac[1], netinfo.mac[2],
           netinfo.mac[3], netinfo.mac[4], netinfo.mac[5]);
    printf("IP:  %d.%d.%d.%d\n",
           netinfo.ip[0], netinfo.ip[1], netinfo.ip[2], netinfo.ip[3]);
    printf("SN:  %d.%d.%d.%d\n",
           netinfo.sn[0], netinfo.sn[1], netinfo.sn[2], netinfo.sn[3]);
    printf("GW:  %d.%d.%d.%d\n",
           netinfo.gw[0], netinfo.gw[1], netinfo.gw[2], netinfo.gw[3]);
}

```

--------------------------------

### Add OID Entry to Source Code

Source: https://github.com/wiznet/iolibrary_driver/blob/master/Internet/SNMP/tools/OID_Converter/Readme.txt

Example of how to add a converted OID entry into the source code of the SNMP agent. It specifies the length, the converted OID value, the data type, and other parameters.

```c
{0x0a, {0x2b, 0x06, 0x01, 0x04, 0x01, 0x81, 0x9b, 0x19, 0x01, 0x00},
SNMPDTYPE_OCTET_STRING, 30, {"long-length OID Test"},
NULL, NULL},
```

--------------------------------

### Register SPI Callback Functions

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Register custom SPI read, write, and chip select functions to enable hardware abstraction for SPI communication. This example shows platform-specific implementations for STM32.

```c
#include "wizchip_conf.h"

// Platform-specific SPI functions (example for STM32)
uint8_t spi_read_byte(void) {
    uint8_t rx_data;
    // Wait until TX buffer empty
    while (!(SPI1->SR & SPI_SR_TXE));
    SPI1->DR = 0xFF;  // Send dummy byte
    // Wait until RX buffer not empty
    while (!(SPI1->SR & SPI_SR_RXNE));
    rx_data = SPI1->DR;
    return rx_data;
}

void spi_write_byte(uint8_t data) {
    while (!(SPI1->SR & SPI_SR_TXE));
    SPI1->DR = data;
    while (!(SPI1->SR & SPI_SR_RXNE));
    (void)SPI1->DR;  // Clear RXNE flag
}

void spi_cs_select(void) {
    GPIO_ResetBits(GPIOA, GPIO_Pin_4);  // CS low
}

void spi_cs_deselect(void) {
    GPIO_SetBits(GPIOA, GPIO_Pin_4);    // CS high
}

void wizchip_spi_init(void) {
    // Register chip select callbacks
    reg_wizchip_cs_cbfunc(spi_cs_select, spi_cs_deselect);

    // Register SPI read/write callbacks
    reg_wizchip_spi_cbfunc(spi_read_byte, spi_write_byte);

    printf("SPI callbacks registered\n");
}

```

--------------------------------

### SNMP Agent API

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Implements an SNMPv1 agent for network device monitoring and management. Supports GET, GET-NEXT, SET requests, and trap notifications.

```APIDOC
## SNMP Agent API

### snmpd_init / snmpd_run - SNMP Agent

### Description
Implements an SNMPv1 agent for network device monitoring and management. Supports GET, GET-NEXT, SET requests, and trap notifications.

### Usage Example
```c
#include "snmp.h"

#define SNMP_SOCKET_AGENT   5
#define SNMP_SOCKET_TRAP    6

// Timer handler (call every 1 second)
void timer_1s_handler(void) {
    SNMP_time_handler();
}

void snmp_agent_setup(void) {
    uint8_t manager_ip[4] = {192, 168, 1, 100};
    uint8_t agent_ip[4] = {192, 168, 1, 10};

    // Initialize SNMP agent
    snmpd_init(manager_ip, agent_ip, SNMP_SOCKET_AGENT, SNMP_SOCKET_TRAP);

    printf("SNMP Agent started on port 161\n");
}

int main(void) {
    int32_t ret;

    // Initialize hardware and network...
    snmp_agent_setup();

    while (1) {
        // Process SNMP requests
        ret = snmpd_run();

        if (ret > 0) {
            printf("SNMP request processed\n");
        }
    }
}
```
```

--------------------------------

### Initialize, Connect, Subscribe, and Publish with MQTT Client

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Sets up an MQTT client, connects to a broker, subscribes to a topic, and publishes messages. Ensure the network interface and client buffers are initialized before use. The MQTTYield function must be called regularly to process incoming messages.

```c
#include "MQTTClient.h"
#include "mqtt_interface.h"

#define MQTT_SOCKET     3 
#define MQTT_BUF_SIZE   2048

uint8_t mqtt_tx_buf[MQTT_BUF_SIZE];
uint8_t mqtt_rx_buf[MQTT_BUF_SIZE];

Network mqtt_network;
MQTTClient mqtt_client;

// Message received callback
void message_handler(MessageData* md) {
    MQTTMessage* msg = md->message;
    printf("Topic: %.*s\n", md->topicName->lenstring.len, md->topicName->lenstring.data);
    printf("Message: %.*s\n", (int)msg->payloadlen, (char*)msg->payload);
}

// Timer handler (call every 1 millisecond)
void timer_1ms_handler(void) {
    MilliTimer_Handler();
}

int mqtt_connect_and_subscribe(void) {
    int rc;
    uint8_t broker_ip[4] = {192, 168, 1, 100};
    uint16_t broker_port = 1883;

    MQTTPacket_connectData connect_data = MQTTPacket_connectData_initializer;

    // Initialize network interface
    NewNetwork(&mqtt_network, MQTT_SOCKET);

    // Connect to MQTT broker
    rc = ConnectNetwork(&mqtt_network, broker_ip, broker_port);
    if (rc != 0) {
        printf("Network connect failed: %d\n", rc);
        return rc;
    }

    // Initialize MQTT client
    MQTTClientInit(&mqtt_client, &mqtt_network, 5000, 
                   mqtt_tx_buf, MQTT_BUF_SIZE, 
                   mqtt_rx_buf, MQTT_BUF_SIZE);

    // Configure connection parameters
    connect_data.MQTTVersion = 3;
    connect_data.clientID.cstring = "wiznet_device_01";
    connect_data.keepAliveInterval = 60;
    connect_data.cleansession = 1;

    // Connect to broker
    rc = MQTTConnect(&mqtt_client, &connect_data);
    if (rc != 0) {
        printf("MQTT connect failed: %d\n", rc);
        return rc;
    }
    printf("MQTT connected\n");

    // Subscribe to topic
    rc = MQTTSubscribe(&mqtt_client, "sensors/temperature", QOS0, message_handler);
    if (rc != 0) {
        printf("Subscribe failed: %d\n", rc);
        return rc;
    }
    printf("Subscribed to sensors/temperature\n");

    return 0;
}

int mqtt_publish_message(char* topic, char* payload) {
    MQTTMessage message;

    message.qos = QOS0;
    message.retained = 0;
    message.payload = payload;
    message.payloadlen = strlen(payload);

    return MQTTPublish(&mqtt_client, topic, &message);
}

int main(void) {
    // Initialize hardware...

    if (mqtt_connect_and_subscribe() != 0) {
        printf("MQTT setup failed\n");
        return -1;
    }

    while (1) {
        // Process MQTT messages (must be called regularly)
        MQTTYield(&mqtt_client, 100);

        // Publish sensor data periodically
        mqtt_publish_message("sensors/status", "online");
    }
}
```

--------------------------------

### Initialize and Run TFTP Client

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initializes the TFTP client and performs a file download. Ensure TFTP_SOCKET and TFTP_BUF_SIZE are defined appropriately. The TFTP_run() function must be called repeatedly to process the transfer.

```c
#include "tftp.h"

#define TFTP_SOCKET     6
#define TFTP_BUF_SIZE   600

uint8_t tftp_buffer[TFTP_BUF_SIZE];

void tftp_timeout_handler(void) {
    // Called on TFTP timeout
}

int tftp_download_file(uint32_t server_ip, char* filename) {
    int ret;

    // Initialize TFTP
    TFTP_init(TFTP_SOCKET, tftp_buffer);

    // Request file read
    TFTP_read_request(server_ip, (uint8_t*)filename);

    printf("Downloading %s from TFTP server...\n", filename);

    // Process TFTP transfer
    do {
        ret = TFTP_run();

        if (ret == TFTP_SUCCESS) {
            printf("Download complete\n");
            break;
        } else if (ret == TFTP_FAIL) {
            printf("Download failed\n");
            break;
        }
        // TFTP_PROGRESS - continue processing
    } while (1);

    TFTP_exit();
    return ret;
}
```

--------------------------------

### Run TCP and UDP Loopback Servers

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Sets up and runs TCP and UDP loopback servers for network testing. This function should be called within the main loop after hardware and network initialization.

```c
#include "loopback.h"

#define TCP_PORT    5000
#define UDP_PORT    5001
#define BUF_SIZE    2048

uint8_t tcp_buffer[BUF_SIZE];
uint8_t udp_buffer[BUF_SIZE];

int main(void) {
    // Initialize hardware and network...

    while (1) {
        // Run TCP loopback server on socket 0
        loopback_tcps(0, tcp_buffer, TCP_PORT);

        // Run UDP loopback server on socket 1
        loopback_udps(1, udp_buffer, UDP_PORT);
    }
}
```

--------------------------------

### wizchip_init - Initialize WIZnet Chip

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initializes the WIZnet chip with specified TX and RX buffer sizes for each socket.

```APIDOC
## wizchip_init - Initialize WIZnet Chip

### Description
Initializes the WIZnet chip with specified TX and RX buffer sizes for each socket. Buffer sizes are allocated from the chip's total memory and must sum to the maximum available (typically 16KB each for TX and RX).

### Method
`wizchip_init`

### Endpoint
N/A (Function call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
// Example with equal buffer allocation
uint8_t tx_buf_sizes[8] = {2, 2, 2, 2, 2, 2, 2, 2};  // 2KB per socket
uint8_t rx_buf_sizes[8] = {2, 2, 2, 2, 2, 2, 2, 2};
wizchip_init(tx_buf_sizes, rx_buf_sizes);

// Example with custom buffer allocation
uint8_t tx_buf_sizes_custom[8] = {8, 2, 2, 2, 1, 1, 0, 0};
uint8_t rx_buf_sizes_custom[8] = {8, 2, 2, 2, 1, 1, 0, 0};
wizchip_init(tx_buf_sizes_custom, rx_buf_sizes_custom);
```

### Response
#### Success Response (Initialization)
- **ret** (int8_t) - Returns 0 or greater on success, negative on failure.

#### Response Example
```c
if (ret >= 0) {
    printf("WIZCHIP initialized successfully\n");
} else {
    printf("WIZCHIP init failed: %d\n", ret);
}
```
```

--------------------------------

### Initialize WIZnet Chip with Default Buffers

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initializes the WIZnet chip with default TX and RX buffer sizes of 2KB per socket. Ensure the total buffer sizes do not exceed the chip's available memory.

```c
#include "wizchip_conf.h"

void initialize_wizchip(void) {
    uint8_t tx_buf_sizes[8] = {2, 2, 2, 2, 2, 2, 2, 2};  // 2KB per socket
    uint8_t rx_buf_sizes[8] = {2, 2, 2, 2, 2, 2, 2, 2};

    int8_t ret = wizchip_init(tx_buf_sizes, rx_buf_sizes);

    if (ret < 0) {
        printf("WIZCHIP init failed: %d\n", ret);
        return;
    }

    printf("WIZCHIP initialized with 2KB buffers per socket\n");
}
```

--------------------------------

### DHCP Client Initialization and Operation

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initialize and run the DHCP client to obtain network configuration automatically. DHCP_run() must be called periodically. Callbacks handle IP assignment, updates, and conflicts.

```c
#include "dhcp.h"
#include "wizchip_conf.h"

#define DHCP_SOCKET     0
#define DHCP_BUF_SIZE   548

uint8_t dhcp_buffer[DHCP_BUF_SIZE];
volatile uint8_t ip_assigned = 0;

// Callback when IP is assigned
void dhcp_ip_assign(void) {
    wiz_NetInfo netinfo;
    getIPfromDHCP(netinfo.ip);
    getSNfromDHCP(netinfo.sn);
    getGWfromDHCP(netinfo.gw);
    getDNSfromDHCP(netinfo.dns);
    netinfo.dhcp = NETINFO_DHCP;
    wizchip_setnetinfo(&netinfo);
    ip_assigned = 1;
    printf("IP assigned via DHCP: %d.%d.%d.%d\n",
           netinfo.ip[0], netinfo.ip[1], netinfo.ip[2], netinfo.ip[3]);
}

// Callback when IP is updated
void dhcp_ip_update(void) {
    printf("DHCP: IP renewed\n");
    dhcp_ip_assign();
}

// Callback when IP conflict detected
void dhcp_ip_conflict(void) {
    printf("DHCP: IP conflict detected!\n");
    ip_assigned = 0;
}

// Timer interrupt handler (call every 1 second)
void timer_1s_handler(void) {
    DHCP_time_handler();
}

int main(void) {
    uint8_t dhcp_status;

    // Initialize hardware and WIZnet chip first...

    // Initialize DHCP
    DHCP_init(DHCP_SOCKET, dhcp_buffer);
    reg_dhcp_cbfunc(dhcp_ip_assign, dhcp_ip_update, dhcp_ip_conflict);

    printf("Starting DHCP client...\n");

    while (1) {
        dhcp_status = DHCP_run();

        switch (dhcp_status) {
        case DHCP_IP_LEASED:
            // IP obtained, can proceed with network operations
            if (ip_assigned) {
                // Your network application here
            }
            break;
        case DHCP_FAILED:
            printf("DHCP failed, retrying...\n");
            DHCP_init(DHCP_SOCKET, dhcp_buffer);
            break;
        }
    }
}

```

--------------------------------

### OID Converter Command Line Usage

Source: https://github.com/wiznet/iolibrary_driver/blob/master/Internet/SNMP/tools/OID_Converter/Readme.txt

Demonstrates the command-line usage for the OID converter tool, showing options for converting dotted OIDs to hex DER and vice versa.

```bash
OID [-c|-C] [-o] {-i|1.2.3.4}
  converts dotted form to ASCII HEX DER output.
OID -x [-o] {-i|hex-digits}
  decodes ASCII HEX DER and gives dotted form.
```

--------------------------------

### Initialize and Run DNS Resolution

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initializes the DNS client and resolves a hostname to an IP address. Call DNS_time_handler() periodically via a timer interrupt.

```c
#include "dns.h"

#define DNS_SOCKET      2
#define DNS_BUF_SIZE    256

uint8_t dns_buffer[DNS_BUF_SIZE];

// Timer interrupt handler (call every 1 second)
void timer_1s_handler(void) {
    DNS_time_handler();
}

int8_t resolve_hostname(char* hostname, uint8_t* resolved_ip) {
    int8_t ret;
    uint8_t dns_server[4] = {8, 8, 8, 8};  // Google DNS

    // Initialize DNS
    DNS_init(DNS_SOCKET, dns_buffer);

    printf("Resolving %s...\n", hostname);

    // Run DNS query (blocking)
    ret = DNS_run(dns_server, (uint8_t*)hostname, resolved_ip);

    if (ret == 1) {
        printf("Resolved: %d.%d.%d.%d\n",
               resolved_ip[0], resolved_ip[1], resolved_ip[2], resolved_ip[3]);
        return 0;
    } else if (ret == 0) {
        printf("DNS resolution failed (timeout)\n");
        return -1;
    } else {
        printf("DNS error: domain name too long\n");
        return -1;
    }
}

// Usage example
void connect_to_server(void) {
    uint8_t server_ip[4];

    if (resolve_hostname("www.example.com", server_ip) == 0) {
        // Connect using resolved IP
        socket(0, Sn_MR_TCP, 50000, 0);
        connect(0, server_ip, 80);
    }
}
```

--------------------------------

### ioLibrary Directory Structure

Source: https://github.com/wiznet/iolibrary_driver/blob/master/README.md

This snippet displays the directory structure of the ioLibrary, showing the organization of application, Ethernet, and Internet modules.

```tree
ioLibrary
    ┣ Application
        ┣ loopback
            ┣ loopback.c
            ┗ loopback.h
        ┗ multicast
            ┣ multicast.c
            ┗ multicast.h
    ┣ Ethernet
        ┣ W5100
            ┣ w5100.c
            ┗ w5100.h
        ┣ W5100S
            ┣ w5100s.c
            ┗ w5100s.h
        ┣ W5200
            ┣ w5200.c
            ┗ w5200.h
        ┣ W5300
            ┣ w5300.c
            ┗ w5300.h
        ┣ W5500
            ┣ w5500.c
            ┗ w5500.h
        ┣ W6100
            ┣ w6100.c
            ┗ w6100.h
        ┗ W6300
            ┣ w6300.c
            ┗ w6300.h
    ┗ Internet
       ┣ AAC
           ┣ AddressAutoConfig.c
           ┗ AddressAutoConfig.h
       ┣ DHCP
           ┣ dhcp.c
           ┗ dhcp.h
       ┣ DHCP6
           ┣ dhcp6.c
           ┗ dhcp6.h
       ┣ DNS
           ┣ dns.c
           ┗ dns.h
       ┣ FTPClient
           ┣ ftpc.c
           ┣ ftpc.h
           ┗ stdio_private.h
       ┣ FTPServer
           ┣ ftpd.c
           ┣ ftpd.h
           ┣ REAME.md
           ┗ stdio_private.h
       ┣ httpServer
           ┣ httpParser.c
           ┣ httpParser.h
           ┣ httpServer.c
           ┣ httpServer.h
           ┣ httpUtil.c
           ┗ httpUtil.h
       ┣ MQTT
           ┣ MQTTPacket
           ┣ mqtt_interface.c
           ┣ mqtt_interface.h
           ┣ MQTTClient.c
           ┗ MQTTClient.h
       ┣ SNMP
           ┣ tools
           ┣ snmp.c
           ┣ snmp.h
           ┣ snmp_custom.c
           ┗ snmp_custom.h
       ┣ SNTP
           ┣ sntp.c
           ┗ sntp.h
       ┗ TFTP
          ┣ netutil.c
          ┣ netutil.h
          ┣ tftp.c
          ┗ tftp.h
```

--------------------------------

### TCP Client Loopback Test

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Establishes a TCP client connection to a specified server IP and port for loopback testing. This function is intended to be run in a loop.

```c
// TCP Client loopback example
void tcp_client_test(void) {
    uint8_t server_ip[4] = {192, 168, 1, 100};
    uint16_t server_port = 5000;

    while (1) {
        loopback_tcpc(2, tcp_buffer, server_ip, server_port);
    }
}
```

--------------------------------

### Initialize and Run Embedded HTTP Server

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initializes and runs an embedded HTTP server. Call httpServer_time_handler() periodically via a timer interrupt and httpServer_run() in a loop for each socket.

```c
#include "httpServer.h"

#define HTTP_SOCKET_COUNT   4
#define HTTP_BUF_SIZE       2048

uint8_t http_socket_list[HTTP_SOCKET_COUNT] = {0, 1, 2, 3};
uint8_t http_tx_buf[HTTP_BUF_SIZE];
uint8_t http_rx_buf[HTTP_BUF_SIZE];

// HTML content to serve
const uint8_t index_html[] =
    "<!DOCTYPE html><html><head><title>WIZnet Device</title></head>"
    "<body><h1>Welcome to WIZnet HTTP Server</h1>"
    "<p>Device Status: Online</p></body></html>";

// Timer handler (call every 1 second)
void timer_1s_handler(void) {
    httpServer_time_handler();
}

// MCU reset callback (optional)
void mcu_reset(void) {
    // Trigger MCU software reset
    NVIC_SystemReset();
}

void http_server_setup(void) {
    // Initialize HTTP server
    httpServer_init(http_tx_buf, http_rx_buf, HTTP_SOCKET_COUNT, http_socket_list);

    // Register callbacks (optional)
    reg_httpServer_cbfunc(mcu_reset, NULL);

    // Register web content
    reg_httpServer_webContent((uint8_t*)"index.html", (uint8_t*)index_html);

    printf("HTTP Server initialized on port 80\n");
}

int main(void) {
    uint8_t i;

    // Initialize hardware and network...
    http_server_setup();

    while (1) {
        // Run HTTP server for each socket
        for (i = 0; i < HTTP_SOCKET_COUNT; i++) {
            httpServer_run(i);
        }
    }
}
```

--------------------------------

### Connect to TCP Server (IPv4)

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initiates a TCP connection to a remote IPv4 server. This function is for W5x00 series chips and requires the server's IP address and port. The socket is opened with an ephemeral port.

```c
#include "socket.h"

#define TCP_SOCKET  0
#define LOCAL_PORT  50000

// For W5x00 series (IPv4 only)
int8_t tcp_client_connect_v4(void) {
    int8_t ret;
    uint8_t server_ip[4] = {192, 168, 1, 100};
    uint16_t server_port = 8080;

    // Open socket with ephemeral port
    ret = socket(TCP_SOCKET, Sn_MR_TCP, LOCAL_PORT, 0x00);
    if (ret != TCP_SOCKET) return ret;

    // Connect to server (3 parameters for W5x00)
    ret = connect(TCP_SOCKET, server_ip, server_port);
    if (ret != SOCK_OK) {
        printf("Connection failed: %d\n", ret);
        close(TCP_SOCKET);
        return ret;
    }

    printf("Connected to %d.%d.%d.%d:%d\n",
           server_ip[0], server_ip[1], server_ip[2], server_ip[3], server_port);
    return SOCK_OK;
}
```

--------------------------------

### MQTT Client API

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Implements an MQTT client for IoT communication with message brokers. Supports QoS 0, 1, and 2, subscriptions, and publish operations.

```APIDOC
## MQTTClientInit / MQTTConnect / MQTTSubscribe / MQTTPublish - MQTT Client

### Description
Implements an MQTT client for IoT communication with message brokers. Supports QoS 0, 1, and 2, subscriptions, and publish operations.

### Usage Example
```c
#include "MQTTClient.h"
#include "mqtt_interface.h"

#define MQTT_SOCKET     3
#define MQTT_BUF_SIZE   2048

uint8_t mqtt_tx_buf[MQTT_BUF_SIZE];
uint8_t mqtt_rx_buf[MQTT_BUF_SIZE];

Network mqtt_network;
MQTTClient mqtt_client;

// Message received callback
void message_handler(MessageData* md) {
    MQTTMessage* msg = md->message;
    printf("Topic: %.*s\n", md->topicName->lenstring.len, md->topicName->lenstring.data);
    printf("Message: %.*s\n", (int)msg->payloadlen, (char*)msg->payload);
}

// Timer handler (call every 1 millisecond)
void timer_1ms_handler(void) {
    MilliTimer_Handler();
}

int mqtt_connect_and_subscribe(void) {
    int rc;
    uint8_t broker_ip[4] = {192, 168, 1, 100};
    uint16_t broker_port = 1883;

    MQTTPacket_connectData connect_data = MQTTPacket_connectData_initializer;

    // Initialize network interface
    NewNetwork(&mqtt_network, MQTT_SOCKET);

    // Connect to MQTT broker
    rc = ConnectNetwork(&mqtt_network, broker_ip, broker_port);
    if (rc != 0) {
        printf("Network connect failed: %d\n", rc);
        return rc;
    }

    // Initialize MQTT client
    MQTTClientInit(&mqtt_client, &mqtt_network, 5000,
                   mqtt_tx_buf, MQTT_BUF_SIZE,
                   mqtt_rx_buf, MQTT_BUF_SIZE);

    // Configure connection parameters
    connect_data.MQTTVersion = 3;
    connect_data.clientID.cstring = "wiznet_device_01";
    connect_data.keepAliveInterval = 60;
    connect_data.cleansession = 1;

    // Connect to broker
    rc = MQTTConnect(&mqtt_client, &connect_data);
    if (rc != 0) {
        printf("MQTT connect failed: %d\n", rc);
        return rc;
    }
    printf("MQTT connected\n");

    // Subscribe to topic
    rc = MQTTSubscribe(&mqtt_client, "sensors/temperature", QOS0, message_handler);
    if (rc != 0) {
        printf("Subscribe failed: %d\n", rc);
        return rc;
    }
    printf("Subscribed to sensors/temperature\n");

    return 0;
}

int mqtt_publish_message(char* topic, char* payload) {
    MQTTMessage message;

    message.qos = QOS0;
    message.retained = 0;
    message.payload = payload;
    message.payloadlen = strlen(payload);

    return MQTTPublish(&mqtt_client, topic, &message);
}

int main(void) {
    // Initialize hardware...

    if (mqtt_connect_and_subscribe() != 0) {
        printf("MQTT setup failed\n");
        return -1;
    }

    while (1) {
        // Process MQTT messages (must be called regularly)
        MQTTYield(&mqtt_client, 100);

        // Publish sensor data periodically
        mqtt_publish_message("sensors/status", "online");
    }
}
```
```

--------------------------------

### TCP Server Loopback Implementation

Source: https://github.com/wiznet/iolibrary_driver/wiki/Home

Implements a non-blocking TCP server for loopback testing. Handles socket creation, listening, connection establishment, data reception, and sending data back to the client. Ensure LOOPBACK_MODE is set to LOOPBACK_MAIN_NOBLCOK.

```c
#include <stdio.h>
#include "loopback.h"
#include "socket.h"
#include "wizchip_conf.h"

#if LOOPBACK_MODE == LOOPBACK_MAIN_NOBLCOK

int32_t loopback_tcps(uint8_t sn, uint8_t* buf, uint16_t port)
{
   int32_t ret;
   uint16_t size = 0, sentsize=0;

#ifdef _LOOPBACK_DEBUG_
   uint8_t destip[4];
   uint16_t destport;
#endif

   switch(getSn_SR(sn))
   {
      case SOCK_ESTABLISHED :
         if(getSn_IR(sn) & Sn_IR_CON)
         {
#ifdef _LOOPBACK_DEBUG_
			getSn_DIPR(sn, destip);
			destport = getSn_DPORT(sn);

			printf("%d:Connected - %d.%d.%d.%d : %d\r\n",sn, destip[0], destip[1], destip[2], destip[3], destport);
#endif
			setSn_IR(sn,Sn_IR_CON);
         }
		 if((size = getSn_RX_RSR(sn)) > 0) // Don't need to check SOCKERR_BUSY because it doesn't not occur.
         {
			if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE;
			ret = recv(sn, buf, size);

			if(ret <= 0) return ret;      // check SOCKERR_BUSY & SOCKERR_XXX. For showing the occurrence of SOCKERR_BUSY.
			sentsize = 0;

			while(size != sentsize)
			{
				ret = send(sn, buf+sentsize, size-sentsize);
				if(ret < 0)
				{
					close(sn);
					return ret;
				}
				sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero.
			}
         }
         break;
      case SOCK_CLOSE_WAIT :
#ifdef _LOOPBACK_DEBUG_
         //printf("%d:CloseWait\r\n",sn);
#endif
         if((ret = disconnect(sn)) != SOCK_OK) return ret;
#ifdef _LOOPBACK_DEBUG_
         printf("%d:Socket Closed\r\n", sn);
#endif
         break;
      case SOCK_INIT :
#ifdef _LOOPBACK_DEBUG_
    	 printf("%d:Listen, TCP server loopback, port [%d]\r\n", sn, port);
#endif
         if( (ret = listen(sn)) != SOCK_OK) return ret;
         break;
      case SOCK_CLOSED:
#ifdef _LOOPBACK_DEBUG_
         //printf("%d:TCP server loopback start\r\n",sn);
#endif
         if((ret = socket(sn, Sn_MR_TCP, port, 0x00)) != sn) return ret;
#ifdef _LOOPBACK_DEBUG_
         //printf("%d:Socket opened\r\n",sn);
#endif
         break;
      default:
         break;
   }
   return 1;
}


int32_t loopback_tcpc(uint8_t sn, uint8_t* buf, uint8_t* destip, uint16_t destport)
{
   int32_t ret; // return value for SOCK_ERRORs
   uint16_t size = 0, sentsize=0;

   // Destination (TCP Server) IP info (will be connected)
   // >> loopback_tcpc() function parameter
   // >> Ex) 
   //	d	uint8_t destip[4] = 	{192, 168, 0, 214};
   //	uint16_t destport = 	5000;

   // Port number for TCP client (will be increased)
   uint16_t any_port = 	50000;

   // Socket Status Transitions
   // Check the W5500 Socket n status register (Sn_SR, The 'Sn_SR' controlled by Sn_CR command or Packet send/recv status)
   switch(getSn_SR(sn))
   {
      case SOCK_ESTABLISHED :
         if(getSn_IR(sn) & Sn_IR_CON)	 // Socket n interrupt register mask; TCP CON interrupt = connection with peer is successful
         {
#ifdef _LOOPBACK_DEBUG_
			printf("%d:Connected to - %d.%d.%d.%d : %d\r\n",sn, destip[0], destip[1], destip[2], destip[3], destport);
#endif
			setSn_IR(sn, Sn_IR_CON);  // this interrupt should be write the bit cleared to '1'
         }

         //////////////////////////////////////////////////////////////////////////////////////////////
         // Data Transaction Parts; Handle the [data receive and send] process
         //////////////////////////////////////////////////////////////////////////////////////////////
		 if((size = getSn_RX_RSR(sn)) > 0) // Sn_RX_RSR: Socket n Received Size Register, Receiving data length
         {
			if(size > DATA_BUF_SIZE) size = DATA_BUF_SIZE; // DATA_BUF_SIZE means user defined buffer size (array)
			ret = recv(sn, buf, size); // Data Receive process (H/W Rx socket buffer -> User's buffer)

			if(ret <= 0) return ret; // If the received data length <= 0, receive failed and process end
			sentsize = 0;

			// Data sentsize control
			while(size != sentsize)
			{
				ret = send(sn, buf+sentsize, size-sentsize); // Data send process (User's buffer -> Destination through H/W Tx socket buffer)
				if(ret < 0) // Send Error occurred (sent data length < 0)
				{
					close(sn); // socket close
					return ret;
				}
				sentsize += ret; // Don't care SOCKERR_BUSY, because it is zero.
			}
         }
		 //////////////////////////////////////////////////////////////////////////////////////////////
         break;

      case SOCK_CLOSE_WAIT :
#ifdef _LOOPBACK_DEBUG_
         //printf("%d:CloseWait\r\n",sn);
#endif
         if((ret=disconnect(sn)) != SOCK_OK) return ret;
#ifdef _LOOPBACK_DEBUG_
         printf("%d:Socket Closed\r\n", sn);
#endif
         break;

      case SOCK_INIT :
#ifdef _LOOPBACK_DEBUG_
    	 printf("%d:Try to connect to the %d.%d.%d.%d : %d\r\n", sn, destip[0], destip[1], destip[2], destip[3], destport);
#endif
    	 if( (ret = connect(sn, destip, destport)) != SOCK_OK) return ret;	//	Try to TCP connect to the TCP server (destination)
         break;

      case SOCK_CLOSED:
    	  close(sn);

```

--------------------------------

### DHCP Client API

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initialize and run the DHCP client to automatically obtain IP address configuration from a DHCP server.

```APIDOC
## DHCP Client API

### DHCP_init / DHCP_run - DHCP Client Operations

### Description
Initializes and runs the DHCP client to automatically obtain IP address configuration from a DHCP server. The `DHCP_run()` function must be called periodically in the main loop.

### Method
- `DHCP_init(SOCKET s, uint8_t *buf)`: Initializes the DHCP client.
- `DHCP_run(void)`: Runs the DHCP client state machine. Should be called periodically.
- `reg_dhcp_cbfunc(dhcp_ip_assign_func ip_assign, dhcp_ip_update_func ip_update, dhcp_ip_conflict_func ip_conflict)`: Registers callback functions for DHCP events.
- `DHCP_time_handler(void)`: Handles DHCP timer events. Should be called periodically (e.g., every second).

### Parameters
#### Request Body (for DHCP_init)
- **s** (SOCKET) - Required - The socket number to be used for DHCP communication.
- **buf** (uint8_t *) - Required - A buffer to store DHCP messages.

#### Request Body (for reg_dhcp_cbfunc)
- **ip_assign** (dhcp_ip_assign_func) - Required - Callback function called when an IP address is assigned.
- **ip_update** (dhcp_ip_update_func) - Required - Callback function called when the IP address is updated (renewed).
- **ip_conflict** (dhcp_ip_conflict_func) - Required - Callback function called when an IP address conflict is detected.

### Return Value (for DHCP_run)
- `DHCP_IP_LEASED`: An IP address has been successfully leased.
- `DHCP_FAILED`: DHCP process failed.
- Other values indicate ongoing DHCP process.

### Request Example
```c
#include "dhcp.h"
#include "wizchip_conf.h"

#define DHCP_SOCKET     0
#define DHCP_BUF_SIZE   548

uint8_t dhcp_buffer[DHCP_BUF_SIZE];
volatile uint8_t ip_assigned = 0;

void dhcp_ip_assign(void) {
    wiz_NetInfo netinfo;
    getIPfromDHCP(netinfo.ip);
    getSNfromDHCP(netinfo.sn);
    getGWfromDHCP(netinfo.gw);
    getDNSfromDHCP(netinfo.dns);
    netinfo.dhcp = NETINFO_DHCP;
    wizchip_setnetinfo(&netinfo);
    ip_assigned = 1;
    printf("IP assigned via DHCP: %d.%d.%d.%d\n",
           netinfo.ip[0], netinfo.ip[1], netinfo.ip[2], netinfo.ip[3]);
}

void dhcp_ip_update(void) {
    printf("DHCP: IP renewed\n");
    dhcp_ip_assign();
}

void dhcp_ip_conflict(void) {
    printf("DHCP: IP conflict detected!\n");
    ip_assigned = 0;
}

void timer_1s_handler(void) {
    DHCP_time_handler();
}

int main(void) {
    uint8_t dhcp_status;

    // Initialize hardware and WIZnet chip first...

    DHCP_init(DHCP_SOCKET, dhcp_buffer);
    reg_dhcp_cbfunc(dhcp_ip_assign, dhcp_ip_update, dhcp_ip_conflict);

    printf("Starting DHCP client...\n");

    while (1) {
        dhcp_status = DHCP_run();

        switch (dhcp_status) {
        case DHCP_IP_LEASED:
            if (ip_assigned) {
                // Your network application here
            }
            break;
        case DHCP_FAILED:
            printf("DHCP failed, retrying...\n");
            DHCP_init(DHCP_SOCKET, dhcp_buffer);
            break;
        }
    }
}
```
```

--------------------------------

### Connect to TCP Server (IPv6)

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Initiates a TCP connection to a remote IPv6 server. This function is for W6100/W6300 series chips and requires the server's IPv6 address and port. An additional parameter specifies the address length (16 for IPv6).

```c
#include "socket.h"

#define TCP_SOCKET  0
#define LOCAL_PORT  50000

// For W6100/W6300 series (IPv4 and IPv6)
int8_t tcp_client_connect_v6(void) {
    int8_t ret;
    // IPv6 address: 2001:db8::1
    uint8_t server_ipv6[16] = {0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00,
                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01};
    uint16_t server_port = 8080;

    ret = socket(TCP_SOCKET, Sn_MR_TCP6, LOCAL_PORT, 0x00);
    if (ret != TCP_SOCKET) return ret;

    // Connect with address length (4 parameters for W6x00)
    ret = connect(TCP_SOCKET, server_ipv6, server_port, 16);  // 16 for IPv6
    if (ret != SOCK_OK) {
        close(TCP_SOCKET);
        return ret;
    }
    return SOCK_OK;
}
```

--------------------------------

### Socket APIs - Open a Socket

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

Opens and initializes a socket with the specified protocol type, port number, and flags. This function creates a socket bound to the given port and ready for TCP/UDP communication. The function returns the socket number on success or a negative error code on failure.

```APIDOC
## socket - Open a Socket

### Description
Opens and initializes a socket with the specified protocol type, port number, and flags. This function creates a socket bound to the given port and ready for TCP/UDP communication. The function returns the socket number on success or a negative error code on failure.

### Method
`socket()`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
#include "socket.h"
#include "wizchip_conf.h"

#define SOCKET_NUM  0
#define PORT_NUM    5000

int main(void) {
    int8_t ret;

    // Open TCP socket (for W5x00 series)
    ret = socket(SOCKET_NUM, Sn_MR_TCP, PORT_NUM, 0x00);
    if (ret != SOCKET_NUM) {
        printf("Socket open failed: %d\n", ret);
        return -1;
    }
    printf("TCP Socket %d opened on port %d\n", SOCKET_NUM, PORT_NUM);

    // Open UDP socket with no-delay flag
    ret = socket(1, Sn_MR_UDP, 5001, SF_IO_NONBLOCK);
    if (ret == 1) {
        printf("UDP Socket 1 opened in non-blocking mode\n");
    }

    // For W6100/W6300: Open IPv6 TCP socket
    // ret = socket(SOCKET_NUM, Sn_MR_TCP6, PORT_NUM, SOCK_IO_NONBLOCK);

    // For W6100/W6300: Open Dual-stack (IPv4/IPv6) UDP socket
    // ret = socket(SOCKET_NUM, Sn_MR_UDPD, PORT_NUM, 0x00);

    return 0;
}
```

### Response
#### Success Response (SOCK_OK)
- **socket_number** (int8_t) - The opened socket number.

#### Response Example
```
TCP Socket 0 opened on port 5000
```
```

--------------------------------

### HTTP Server API

Source: https://context7.com/wiznet/iolibrary_driver/llms.txt

API for initializing and running an embedded HTTP server to serve web pages and handle requests.

```APIDOC
## HTTP Server API

### httpServer_init / httpServer_run - Embedded Web Server

### Description
Implements an embedded HTTP server for serving web pages and handling REST API requests. Supports multiple concurrent connections and custom content registration.

### Method
Not Applicable (C function calls)

### Endpoint
Not Applicable (C function calls, typically port 80)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```c
#include "httpServer.h"

// HTML content to serve
const uint8_t index_html[] =
    "<!DOCTYPE html><html><head><title>WIZnet Device</title></head>"
    "<body><h1>Welcome to WIZnet HTTP Server</h1>"
    "<p>Device Status: Online</p></body></html>";

// MCU reset callback (optional)
void mcu_reset(void) {
    // Trigger MCU software reset
    NVIC_SystemReset();
}

void http_server_setup(void) {
    uint8_t http_socket_list[4] = {0, 1, 2, 3};
    uint8_t http_tx_buf[2048];
    uint8_t http_rx_buf[2048];

    // Initialize HTTP server
    httpServer_init(http_tx_buf, http_rx_buf, 4, http_socket_list);

    // Register callbacks (optional)
    reg_httpServer_cbfunc(mcu_reset, NULL);

    // Register web content
    reg_httpServer_webContent((uint8_t*)"index.html", index_html);

    printf("HTTP Server initialized on port 80\n");
}

int main(void) {
    uint8_t i;
    // Initialize hardware and network...
    http_server_setup();

    while (1) {
        // Run HTTP server for each socket
        for (i = 0; i < 4; i++) {
            httpServer_run(i);
        }
    }
}
```

### Response
#### Success Response (HTTP 200 OK)
- **Content**: Served web page or API response.

#### Response Example
```html
<!DOCTYPE html><html><head><title>WIZnet Device</title></head><body><h1>Welcome to WIZnet HTTP Server</h1><p>Device Status: Online</p></body></html>
```
```
Tokens:
Raw