Tcp ip external code

Question

Hello forum. Currently I'm trying to establish a TCP/IP connection between a server and client, in which the client has to be a labview written VI. The server and client communicates via a certain protocol. Can someone "translate' this protocol to Labview?
Description of the communication protocol
1. Introduction
The communication between Client and Server application is based on request – response rule. Client application side requests and server side responses to it.
Request is sent by the Client to the Server side. Type of request (and the response as well) is recognized by command number (field Command in the sent structure). Next, depending on type of request, Server responses to client by sending requested data.
2. General frame structure
The frame structure is like shown below:
FRAME = HEADER + DATA
Header consists of following fields:
 Type of command (public ushort Command) – describes type of request (or response)
 Size of whole data package (header + data) (public int Lenght)
 Number of the next sent frame (public ushort CommandNo)
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct Header
public ushort Command;
public int Lenght;
public ushort CommandNo;
3. Command types and numbers
Command types and numbers are shown below:
a) Commands sent by Client application
 LAN_CODE_GET_GPS_INFORMATION = 0x0005 – requests to calculate and send new position
 INTERNAL_CODE1 = 0x0007 – reserved
 INTERNAL_CODE2 = 0x0008 – reserved
b) Commands sent by Server application
 LAN_CODE_GPS_INFORMATION = 0x0006 – sends calculated position
 INTERNAL_CODE3 = 0x0009 – reserved
/// <summary>
/// Commands sent between client and server.
/// </summary>
public enum Commands
LAN_CODE_GET_GPS_INFORMATION = 0x0005,
LAN_CODE_GPS_INFORMATION = 0x0006,
INTERNAL_CODE4 = 0x0007,
INTERNAL_CODE5 = 0x0008,
INTERNAL_CODE6 = 0x0009,
4. Detail description of the commands
4.1 Requests
4.1.1 Calculate and send new position request
This request is sent by the client in order to calculate and send new position on the track by the server. Server reacts on it by sending calculated data in response described in 4.2.2 paragraph.
a) Header
ushort Command = LAN_CODE_GET_GPS_INFORMATION = 0x0005
int Length = sizeof(Header)
ushort CommandNo – unknown value (next message number)
b) Data
No additional data.
4.2 Responses
4.2.1 Sending calculated GPS position with additional data
This response is reaction to "Calculate and send new position" request (paragprah 4.1.1). The position (and additional data) is sent in packed GPSInfo structure.
a) Header
ushort Command = LAN_CODE_GPS_INFORMATION = 0x0006
int Length = sizeof(Header) + sizeof(GPSInfo)
ushort CommandNo – unknown value (next message number)
b) Data
Data is sent binary in structure shown below packed to byte array.
/// <summary>
/// Structure containing calculated data with additional info.
/// </summary>
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct GPSInfo
/// <summary>
/// Calculated position.
/// </summary>
public PositionSt Position;
/// <summary>
/// Section id, on which train is.
/// </summary>
public int IdSection;
/// <summary>
/// USISID, on which train is.
/// </summary>
public double USISID;
/// <summary>
/// Actual mileage (in section).
/// </summary>
public double SectionMileage;
/// <summary>
/// Begin mileage of the section.
/// </summary>
public double SectionBeginMileage;
/// <summary>
/// End mileage of the section.
/// </summary>
public double SectionEndMileage;
/// <summary>
/// Mileage from odometer.
/// </summary>
public double OdometerMileage;
/// <summary>
/// Structure describing batteries status of the GPS.
/// </summary>
public BatteriesSt Batteries;
/// <summary>
/// Actual time.
/// </summary>
public double DateTimeInfo;
/// <summary>
/// Actual speed.
/// </summary>
public double Speed;
/// <summary>
/// Defines if navigation needs choosing leg by the user.
/// </summary>
public int NeedChoosing;
/// <summary>
/// Defines if sent position is unknown (when we don’t know on which leg we are)
/// </summary>
public int PositionUnknown;
/// <summary>
/// Number of the first leg.
/// </summary>
public double Leg1;
/// <summary>
/// Number of the second leg.
/// </summary>
public double Leg2;
/// <summary>
/// Defines if section, on which we are is properly defined in database.
/// </summary>
public int WrongObject;
/// <summary>
/// Defines ‘virtual’ mileage of the non-properly defined section.
/// </summary>
public int WrongMileage;
/// <summary>
/// Non calculated raw gps position.
/// </summary>
public PositionSt RawGPSPosition;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct BatteriesSt
/// <summary>
/// Percentage of batteries load.
/// </summary>
public double Percentage;
/// <summary>
/// Voltage of the batteries.
/// </summary>
public double Voltage;
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct PositionSt
public double X;
public double Y;
public double Z;

Answer 1

Some more very general info, not so much the TCP itself, but how to deal with those data structures.
The TCP interface in LabVIEW takes strings.  So you'll have to convert the packets into the right kind of data structure.
1. You'll probably want to define LabVIEW datatypes corresponding to the various structs defined in the header.  A LabVIEW cluster is the element that is most like a struct.
2. As you populate the cluster with native datatypes, be careful to use the correct ones.  When you drop a numeric control, LabVIEW treats it as a double by default.  You can then right click and change the representation to the right kind.  Be careful about the size of your integers too!  You'll need to know whether a ushort means 16 or 32 bits for example.
3. The memory layout order for a LabVIEW cluster is not necessarily the same as the visual order.  You'll need to right-click the cluster border in order to define the correct order of all the items within the cluster.
4. Back on the cluster border, right-click and choose Advanced->Customize...  This brings up the custom control editor.  Make your custom data type into a typedef.
5. The LabVIEW function Unflatten from String is probably the best way to convert the received TCP string into the typedef'ed cluster's datatype.
6. For debug and troubleshooting of this conversion, be sure you have a way for your server to send a known non-default struct so you can validate what you receive and interpret.
-Kevin P.