UDP Network Programming in VxWorks

VxWorks is a high-performance real-time operating system widely used in embedded systems, and its network programming capabilities rely on a powerful network protocol stack that supports standard protocols such as TCP/IP and UDP.VxWorks‘s network programming interface is highly compatible with the POSIX socket API, allowing developers to use familiar functions such as socket(), bind(), sendto(), and recvfrom() for communication. Additionally, leveraging VxWorks’ real-time characteristics, network tasks can efficiently run through a multitasking mechanism (such as taskSpawn), meeting the demands for low latency and high reliability. VxWorks provides libraries such as sockLib and inetLib to support network functionality, suitable for network application development in fields like industrial control and aerospace. Developers should pay attention to system network configuration (such as IP address and routing) and resource management to fully utilize its advantages in embedded environments.

This article briefly introduces how to perform UDP socket programming under the VxWorks system.

Overview of UDP

UDP allows applications to send encapsulated IP packets without establishing a connection. As a connectionless transport layer protocol in the OSI reference model, UDP is mainly used for transmissions where the order of packet arrival is not critical, with the application layer responsible for checking and sorting the order of packets. It provides a transaction-oriented, simple, and unreliable messaging service. Essentially, UDP serves as the interface between the IP protocol and upper-layer protocols. It uses ports to enable multiple applications to run on the same device. UDP provides connectionless communication and does not guarantee the reliability of transmitted packets, making it suitable for scenarios where small amounts of data are transmitted in one go, with reliability managed by the application layer.

The communication process of UDP sockets is simpler than that of TCP because it is a connectionless protocol that does not require establishing a connection or maintaining state. The basic process of UDP socket communication is described in concise language as follows:

1. Create Socket

Both the sender and receiver create a UDP socket. This can be implemented using the socket function in programming languages (such as C, Python, Java, etc.), specifying the protocol type as UDP.

2. Bind Address and Port (Receiver)

The receiver needs to bind the socket to a specific IP address and port number to listen for data from the sender. This is accomplished through the bind() operation. The sender typically does not need to bind unless a specific source port is required.

3. Send Data (Sender)

The sender uses the socket with the sendto() function to send packets to the target IP address and port number. The packet contains target address information, so there is no need to establish a connection beforehand.

4. Receive Data (Receiver)

The receiver uses the socket with the recvfrom() function to listen for and receive packets. The received data includes the address information of the sender, which the receiver can process as needed.

5. Repeat or Close

The sender and receiver can repeatedly send and receive data as needed. Since UDP is connectionless, there is no need to explicitly close the connection, but the socket resources can be released using close() after use.

Features and Considerations:

• Connectionless: No handshake is required before sending; data is sent directly.
• Unreliable: Does not guarantee data delivery or order; packet loss or disorder is handled by the application layer.
• Lightweight and Fast: Lacks connection management and retransmission mechanisms, making it suitable for scenarios with high real-time requirements (such as video streaming, DNS queries).

Writing a UDP socket program under VxWorks requires using the network programming interface provided by VxWorks, which is similar to the POSIX socket API, but attention must be paid to the real-time characteristics of the operating system and task management. Below is a simple example of a VxWorks UDP communication program, including basic implementations for both the sender and receiver. We will assume this is a single-task program, showcasing the logic for sending and receiving separately.

Example Code

Implementing UDP sending and receiving in VxWorks

#include <vxWorks.h>
#include <sockLib.h>
#include <inetLib.h>
#include <stdio.h>
#include <string.h>
#include <taskLib.h>

#define SERVER_PORT 12345          /* Receiver port number */
#define SERVER_IP "192.168.1.100"  /* Receiver IP address */
#define BUFFER_SIZE 1024           /* Buffer size */

/* UDP sending task */
void udpSender(void)
{
    int sockfd;
    struct sockaddr_in serverAddr;
    char sendBuffer[BUFFER_SIZE] = "Hello from VxWorks UDP Sender!";

    /* Create UDP socket */
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == ERROR)
    {
        printf("Failed to create sender socket\n");
        return;
    }

    /* Configure target address */
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(SERVER_PORT);
    serverAddr.sin_addr.s_addr = inet_addr(SERVER_IP);

    /* Send data */
    while (1)
    {
        int bytesSent = sendto(sockfd, sendBuffer, strlen(sendBuffer), 0,
                               (struct sockaddr *)&serverAddr, sizeof(serverAddr));
        if (bytesSent == ERROR)
        {
            printf("Failed to send data\n");
            close(sockfd);
            return;
        }
        printf("Sent: %s\n", sendBuffer);
        taskDelay(60); /* Delay 1 second (assuming sysClkRateGet() is 60 ticks/sec) */
    }

    /* Close socket (may not reach here in practice) */
    close(sockfd);
}

/* UDP receiving task */
void udpReceiver(void)
{
    int sockfd;
    struct sockaddr_in serverAddr, clientAddr;
    char recvBuffer[BUFFER_SIZE];
    int addrLen = sizeof(clientAddr);

    /* Create UDP socket */
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == ERROR)
    {
        printf("Failed to create receiver socket\n");
        return;
    }

    /* Configure local address and bind */
    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(SERVER_PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY; /* Listen on all interfaces */

    if (bind(sockfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) == ERROR)
    {
        printf("Bind failed\n");
        close(sockfd);
        return;
    }

    printf("UDP Receiver listening on port %d...\n", SERVER_PORT);

    /* Receive data */
    while (1)
    {
        int bytesReceived = recvfrom(sockfd, recvBuffer, BUFFER_SIZE - 1, 0,
                                     (struct sockaddr *)&clientAddr, &addrLen);
        if (bytesReceived == ERROR)
        {
            printf("Failed to receive data\n");
            close(sockfd);
            return;
        }

        recvBuffer[bytesReceived] = '\0'; /* Ensure string termination */
        printf("Received from %s:%d: %s\n",
               inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port), recvBuffer);
    }

    /* Close socket (may not reach here in practice) */
    close(sockfd);
}

/* Main function: Start sending and receiving tasks */
void startUdpTasks(void)
{
    /* Start receiving task */
    if (taskSpawn("tUdpReceiver", 100, 0, 20000, (FUNCPTR)udpReceiver,
                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)
    {
        printf("Failed to spawn udpReceiver task\n");
    }

    /* Start sending task */
    if (taskSpawn("tUdpSender", 100, 0, 20000, (FUNCPTR)udpSender,
                  0, 0, 0, 0, 0, 0, 0, 0, 0, 0) == ERROR)
    {
        printf("Failed to spawn udpSender task\n");
    }
}

Code Explanation

1. Header Files:

• sockLib.h and inetLib.h are the socket and network function libraries provided by VxWorks.
• taskLib.h is used for task management.

2. Sender (udpSender):

• Creates a UDP socket.
• Configures the target address (SERVER_IP and SERVER_PORT).
• Uses sendto() to send the string once per second (implemented via taskDelay).

3. Receiver (udpReceiver):

• Creates a UDP socket and binds it to the specified port (SERVER_PORT).
• Uses recvfrom() to receive data and prints the sender’s IP and port information.

4. Main Function (startUdpTasks):

• Uses taskSpawn to create two tasks to run the sending and receiving logic.
• Task priority is set to 100, and stack size is 20000 bytes.

Usage Instructions

• Load the code onto the VxWorks target system (via Workbench or command line).
• Call startUdpTasks() in the VxWorks shell to start the program.
• Ensure the network configuration is correct (target IP and port are reachable).

Considerations

• Network Configuration: The VxWorks network stack needs to be configured in advance (e.g., set IP via ifconfig).
• Task Delay: taskDelay(60) assumes a system clock frequency of 60 ticks/sec, which should be adjusted based on the actual system.
• Error Handling: The error handling in the example is quite simple; it should be more robust in actual applications.
• Local Testing: You can set SERVER_IP to “127.0.0.1” to test on the same device.