使用UDP LabVIEW与UDP c ++套接字通信

Question

I have to integrate LabVIEW and C++ code that will eventually go on an off board processor on an FRC Robot.

I only started programming in C++ a couple of months ago, so I have little experience with doing anything too complex in C++.

I decided to integrate LabVIEW and C++ through UDP communication (I chose UDP over TCP because I tried TCP and it generated too much lag for my purposes). I wrote my program C++ client UDP program, but when it came to programming my UDP program in LabVIEW, I got confused.

In C++ there seems to be a clear distinction between client and server UDP programs. In C++ it seems that the client tries to connect to the server and the server responds. However, in LabVIEW, the server seems to be determined by who sends first.

My C++ code is below along with a picture of my attempt at a LabVIEW program that didn't work. Thank you for any help you provide (ps if you could show me how to do this using a dll that would be very helpful because I couldn't find any good help).

#include <winsock2.h>
#include <ws2tcpip.h>
#include <stdio.h>
#include <iostream>
#include <Windows.h>

#pragma comment(lib, "Ws2_32.lib")

using namespace std;

#define Input_PORT "0914"
#define Output_PORT "152120"
#define General_PORT "444"

int main(int argc, char* argv[]) {

    WSADATA wsaData; //data for winsock

    int iResult; //result of intelizing winsock

    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);
    if (iResult != 0) {
        printf("WSAStartup failed: %d\n", iResult);
        return 1;
    }
    printf("WSA Intelized: %d\n", iResult);

    system("pause");

    //Creating Socket
    struct addrinfo *result = NULL, *ptr = NULL, hints;

    ZeroMemory(&hints, sizeof(hints));
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

    // Resolve the server address and port
    iResult = getaddrinfo(argv[1], General_PORT, &hints, &result);
    if (iResult != 0) {
        printf("getaddrinfo failed: %d\n", iResult);
        WSACleanup();
        return 1;
    }

    SOCKET ConnectSocket = INVALID_SOCKET; //Create Connecting Socket

                                           // Attempt to connect to the first address returned by
                                           // the call to getaddrinfo
    ptr = result;

    // Create a SOCKET for connecting to server
    ConnectSocket = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);


    if (ConnectSocket == INVALID_SOCKET) {
        printf("Error at socket(): %ld\n", WSAGetLastError());
        freeaddrinfo(result);
        WSACleanup();
        return 1;
    }

    printf("Socket Created\n");
    system("pause");

    // Connect to server.
    iResult = connect(ConnectSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
    if (iResult == SOCKET_ERROR) {
        closesocket(ConnectSocket);
        ConnectSocket = INVALID_SOCKET;
    }

    // Should really try the next address returned by getaddrinfo
    // if the connect call failed
    // But for this simple example we just free the resources
    // returned by getaddrinfo and print an error message

    freeaddrinfo(result);

    if (ConnectSocket == INVALID_SOCKET) {
        printf("Unable to connect to server!\n");
        WSACleanup();
        return 1;
    }

    printf("Connected\n");
    system("pause");

    return 0;
}

LabVIEW Block Diagram

Answer 1

The UDP protocol in general has no "connection", it is connectionless. A packet gets send out to an IP address and a port and there is no supervision if that packet gets received or not.

Both sides can listen on an UDP ports as well as they can send data to another UDP ports/IP addresses in the network. If you call one side server (because it is responding to a command) or client (because it is sending a command an it is awaiting a repsonse to it) is just defined by your application.

An UDP packet contains a "destination port number" as well as a "source port number". A receiver listens on a specific port (which is for the sender the "destination port") and the sender sends data to this port. The receiver gets with the "source port number" from the sender the information where the other side is listening for the case that it wants to send something back.

I found there some helpful information regarding "UDP socket programming in winsock", which I used for my test programm (i cannot post more links right now with my reputation status, so please add http:// on your own to it): www.binarytides.com/udp-socket-programming-in-winsock

#include "stdafx.h"

#include<stdio.h>
#include<winsock2.h>
#include <Ws2tcpip.h>

#pragma comment(lib,"ws2_32.lib") // Winsock Library

#define REMOTE_SERVER_NAME "127.0.0.1"  // IP address of udp remote server
#define REMOTE_SERVER_PORT 61557    // UDP port of the remote server which is listening
#define LOCAL_RCV_BUF_LEN 20    // max. length of receiving buffer
#define LOCAL_CMD_MSG_LEN 10    // max. length of command to send

int main(void)
{
    struct sockaddr_in sockaddr_in1;    // the SOCKADDR_IN structure specifies a transport address and port for the AF_INET address family.
    int socket1;    // descriptor referencing the socket
    int sockaddr_in1_len = sizeof(sockaddr_in1);
    char cmd_message[LOCAL_CMD_MSG_LEN];    // command message, read from input keys, send to the UDP server
    char rcv_buf[LOCAL_RCV_BUF_LEN];    // receive buffer to store received data
    WSADATA wsdata1;    // contains information about the Windows Sockets implementation

    // initialise winsock
    printf("\nInitialising Winsock...");
    if (WSAStartup(MAKEWORD(2, 2), &wsdata1) != 0)
    {
        printf("Failed. Error Code : %d", WSAGetLastError());
        exit(EXIT_FAILURE);
    }
    printf("Initialised.\n");

    // create socket
    if ((socket1 = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == SOCKET_ERROR)
    {
        printf("socket() failed with error code : %d", WSAGetLastError());
        exit(EXIT_FAILURE);
    }

    // setup address structure
    memset((char *)&sockaddr_in1, 0, sizeof(sockaddr_in1));
    sockaddr_in1.sin_family = AF_INET;
    sockaddr_in1.sin_port = htons(REMOTE_SERVER_PORT);
    inet_pton(AF_INET, REMOTE_SERVER_NAME, &sockaddr_in1.sin_addr.S_un.S_addr);

    // start communication
    while (1)
    {
        printf("Enter command (d=date, t=time) : ");
        gets_s(cmd_message, sizeof(cmd_message) - 1);

        // send the message
        if (sendto(socket1, cmd_message, strlen(cmd_message), 0, (struct sockaddr *) &sockaddr_in1, sizeof(sockaddr_in1)) == SOCKET_ERROR)
        {
            printf("sendto() failed with error code : %d", WSAGetLastError());
            exit(EXIT_FAILURE);
        }

        // receive a reply and print it
        memset(rcv_buf, '\0', sizeof(rcv_buf)); // clear the buffer by filling null, it might have previously received data
        // try to receive some data, this is a blocking call
        if (recvfrom(socket1, rcv_buf, sizeof(rcv_buf), 0, (struct sockaddr *) &sockaddr_in1, &sockaddr_in1_len) == SOCKET_ERROR)
        {
            printf("recvfrom() failed with error code : %d", WSAGetLastError());
            exit(EXIT_FAILURE);
        }

        puts(rcv_buf);
    }

    closesocket(socket1);
    WSACleanup();

    return 0;
}

LabVIEW has four functions which are important in this context:

• UDP Open (gets a port to listen on)
• UDP Read (reads data from the port defined at "UDP Open", provides the remote port from a received package to send data back)
• UDP Write (gets data to send as well as a remote port)
• UDP Close

LabVIEW Code

If required, you can download my test source from the following destination (same thing with the link as mentioned above): dl.dropboxusercontent.com/u/16833149/Simple%20UDP%20-%20Command%20Receiver.7z