Wiznet makers

1 Introduction

NetBIOS over TCP/IP became widely used from the late 1980s, as TCP/IP replaced the OSI model as the de facto standard, and NetBIOS became the basis for many other network applications. Many LANs work on the basis of the NetBIOS protocol.

 W5100S/W5500 is an embedded Ethernet controller integrating a full hardware TCP/IP protocol stack. It is also an industrial-grade Ethernet control chip. This tutorial will introduce the basic principles, usage steps, application examples and precautions of W5100S/W5500 Ethernet DHCP application to help readers better master this technology.

2 Protocol Introduction

2.1 What is NetBIOS?

NetBIOS (Network Basic Input/Output System) is an application programming interface (API) that is used in LAN programs to provide a unified command set for programs to request low-level services. Its function is to provide network services and other special functions to the LAN.

2.2 Advantages of NetBIOS

Advantages of the NetBIOS protocol include:

You can directly use the host name to find other hosts without knowing the other party's IP address.

All resources on the host, such as disks, printers, etc., can be shared.

Has good cross-platform and compatibility.

Short and concise, with good network communication performance, it is suitable for small LAN network environments with high timeliness. ·

2.3 How NetBIOS works

The steps to implement the NetBIOS protocol are as follows:

First, when the computer starts or after starting, it will execute a program called "nbtstat", which will broadcast its own name (NetBIOS name) to the network.

Secondly, when a data packet arrives, the system will check the destination IP address of the data packet. If it is a broadcast or multicast address, the system will send the data packet directly to all interfaces configured with the same broadcast address or multicast address. .

The system then looks at the NetBIOS header information of the packet, which contains the NetBIOS name of the destination computer. The system will search the local NetBIOS name table, and if a matching name is found, the system will send the data packet to the corresponding interface.

Finally, if the system does not find a matching name, the system drops the packet.

2.4 NetBIOS application scenarios

NetBIOS protocol is widely used in local area networks. The following are some common application scenarios:

Shared files and printers: The NetBIOS protocol allows files and printers to be shared within a local area network. All computers connected to the same network can access these resources by specifying their NetBIOS names.

Remote login: NetBIOS protocol can realize remote login and management of other computers through Terminal Services (Terminal Services) or Remote Desktop connection.

Network management tools: NetBIOS protocol is commonly used in network management tools, such as network monitors, network diagnostic tools, etc., to monitor and manage computers and devices in the network.

Database sharing: The NetBIOS protocol can be used for database sharing, allowing data exchange and sharing between different computers.

Multimedia transmission: NetBIOS protocol is suitable for transmitting multimedia data such as audio and video, and can realize real-time audio and video transmission in a local area network.

3 WIZnet Ethernet chip

WIZnet mainstream hardware protocol stack Ethernet chip parameter comparison

W5100S/W6100 supports 8-bit data bus interface, and the network transmission speed will be better than W5500.

W6100 supports IPV6 and is compatible with W5100S hardware. If users who already use W5100S need to support IPv6, they can be Pin to Pin compatible.

W5500 has more Sockets and send and receive buffers than W5100S.

4 NetBIOS network setting example overview and usage

4.1 Flowchart

The running block diagram of the program is as follows:

4.2 Core preparation work

Software

Visual Studio Code

WIZnet UartTool

Hardware

W5100SIO module + RP2040 Raspberry Pi Pico development board or WIZnet W5100S-EVB-Pico development board

Micro USB interface data cable

TTL to USB

cable

4.3 Connection method

Connect the USB port of the PC through the data cable (mainly used for burning programs, but can also be used as a virtual serial port)

Convert TTL serial port to USB and connect the default pin of UART0:

RP2040 GPIO0 (UART0 TX) <----> USB_TTL_RX

RP2040 GPIO1 (UART0 RX) <----> USB_TTL_TX

When wiring using module connection RP2040

RP2040 GPIO16 <----> W5100S MISO

RP2040 GPIO17 <----> W5100S CS

RP2040 GPIO18 <----> W5100S SCK

RP2040 GPIO19 <----> W5100S MOSI

RP2040 GPIO20 <----> W5100S RST

Connect the PC and device to the router LAN port through network cables

4.4 Main code overview

We are using the official ioLibrary_Driver library of WIZnet. The library supports rich protocols and is easy to operate. The chip integrates the TCP/IP protocol stack on the hardware. The library also encapsulates the protocols above the TCP/IP layer. We only need to simply call the corresponding function to complete the application of the protocol. .

Step 1: Add the corresponding .h file to the arp_client.c file.

Step 2: Define the macros required for DHCP configuration.

Step 3: Configure network information and turn on DHCP mode.

Step 4: Write a timer callback processing function for the DHCP 1s tick timer processing function.

Step 5: The main function first initializes the serial port and SPI, and then writes the network configuration parameters of W5100S. After initializing DHCP, the main loop starts DHCP to obtain the IP. When obtained, it prints the obtained IP. When the number of acquisitions exceeds the maximum number of acquisitions, Use a static IP.

#include <stdio.h>
#include "pico/stdlib.h"
#include "pico/binary_info.h"
#include "hardware/spi.h"
​
#include "wizchip_conf.h"
#include "bsp_spi.h"
#include "dhcp.h"    // Use dhcp
#include "socket.h"  // Use socket
#include "netbios.h" // Use arp
​
#define SOCKET_ID 0                      // Socket number
#define ETHERNET_BUF_MAX_SIZE (1024 * 2) // Send and receive cache size
#define DHCP_RETRY_COUNT 5               // DHCP retry times
#define SOCK_NETBIOS 3
​
/**
 * @brief   Timer callback processing function, used for dhcp timing processing
 * @param   repeating :Timer structure
 * @return  bool
 */
bool repeating_timer_callback(struct repeating_timer *t);
​
/**
 * @brief   Initialization of chip network information
 * @param   conf_info :Static configuration information
 * @return  none
 */
void network_init(wiz_NetInfo *conf_info);
​
/* Network information to be configured. */
wiz_NetInfo net_info = {
    .mac = {0x80, 0x08, 0xdc, 0x1e, 0xed, 0x2e}, // Configured MAC address
    .ip = {192, 168, 1, 10},                     // Configured IP address
    .sn = {255, 255, 255, 0},                    // Configured subnet mask
    .gw = {192, 168, 1, 1},                      // Configured gateway
    .dns = {8, 8, 8, 8},                         // Configured domain address
    .dhcp = NETINFO_DHCP};                       // Configured dhcp model,NETINFO_DHCP:use dhcp; NETINFO_STATIC: use static ip.
​
static uint8_t ethernet_buf[ETHERNET_BUF_MAX_SIZE] = {
    0,
};                                            // Send and receive cachestatic uint8_t destip[4]={192, 168, 1, 2};  // udp destination ip
static uint8_t dest_ip[4] = {192, 168, 1, 2}; // UDP IP address
static uint8_t breakout_flag = 0;             // Define the DHCP acquisition flag
​
int main()
{
    struct repeating_timer timer; // Define the timer structure
    wiz_NetInfo get_info;
    /* MCU init */
    stdio_init_all();     // Initialize the main control peripheral
    wizchip_initialize(); // Initialize the chip interface
    wizchip_setnetinfo(&net_info); // Configure once first
    
    /*dhcp init*/
    DHCP_init(SOCKET_ID, ethernet_buf);                                   // DHCP initialization
    add_repeating_timer_ms(1000, repeating_timer_callback, NULL, &timer); // Add DHCP 1s Tick Timer handler
​
    printf("wiznet chip netbios example.\r\n");
    network_init(&net_info);              // Configuring Network Information
    print_network_information(&get_info); // Read back the configuration information and print it
​
    while (true)
    {
        do_netbios(SOCK_NETBIOS); // NetBIOS
    }
}
​
void network_init(wiz_NetInfo *conf_info)
{
    int count = 0;
    uint8_t dhcp_retry = 0;
​
    if (conf_info->dhcp == NETINFO_DHCP)
    {
        while (true)
        {
            switch (DHCP_run()) // Do the DHCP client
            {
            case DHCP_IP_LEASED: // DHCP resolves the domain name successfully
            {
                if (breakout_flag == 0)
                {
                    printf("DHCP success\r\n");
                    getIPfromDHCP((*conf_info).ip);
                    getGWfromDHCP((*conf_info).gw);
                    getSNfromDHCP((*conf_info).sn);
                    getDNSfromDHCP((*conf_info).dns);
                    wizchip_setnetinfo(conf_info); // Configuring Network Information
                    close(SOCKET_ID);              // After dhcp close the socket, avoid errors in later use
                    breakout_flag = 1;
                }
                break;
            }
            case DHCP_FAILED:
            {
                printf(" DHCP failed \r\n");
                count++;
                if (count <= DHCP_RETRY_COUNT) // If the number of times is less than or equal to the maximum number of times, try again
                {
                    printf("DHCP timeout occurred and retry %d \r\n", count);
                }
                else if (count > DHCP_RETRY_COUNT) // If the number of times is greater than DHCP fails
                {
                    breakout_flag = 1; // if DHCP fail, use the static
                    DHCP_stop();       // Stop processing DHCP protocol
                    conf_info->dhcp = NETINFO_STATIC;
                    wizchip_setnetinfo(conf_info); // Configuring Network Information
                    break;
                }
                break;
            }
            }
            if (breakout_flag)
            {
                printf("config succ\r\n");
                break;
            }
        }
    }
    else
    {
        wizchip_setnetinfo(conf_info); // Configuring Network Information
    }
}
​
bool repeating_timer_callback(struct repeating_timer *t)
{
    DHCP_time_handler(); // DHCP 1s Tick Timer handler
    return true;
}
​

4.5 Results demonstration

1. Open WIZ UartTool and fill in the parameters: select the com port corresponding to the serial port, baud rate 115200, 8 data bits, 1 stop bit, no check bit, no flow control. After filling in the parameters, click open.

2. After opening the serial port, press the reset button to see the serial port printing the information obtained by DHCP, in which the IP is 192.168.1.138.

3. The IP obtained through PING on the PC terminal is found to be able to PING successfully, so DHCP is successful.

5 Precautions

If we want to use WIZnet's W5500 to implement the example in this chapter, we only need to modify two places:

(1) Find the wizchip_conf.h header file under library/ioLibrary_Driver/Ethernet/ and modify the WIZCHIP macro definition to W5500.

(2) Find the CMakeLists.txt file under library and set COMPILE_SEL to ON. OFF is W5100S and ON is W5500.