在Python中读取LabVIEW TCP数据（平化字符串/数据簇）

Question

I have a LabVIEW application that is flattening a cluster (array) of Doubles to a string, before transmitting over TCP/IP to my python application. It does this because TCP/IP will only transmit strings.

The problem is that python reads the string as a load of nonsense ASCII characters, and I can't seem to unscramble them back to the original array of doubles.

How do I interpret the string data that LabVIEW sends after flattening a data strings. My only hint of useful information after hours of google was a PyPI entry called pyLFDS, however it has since been taken down.

Answer 1

The LabVIEW flattened data format is described in some detail here . That document doesn't explicitly describe how double-precision floats (DBL type) are represented, but a little more searching found this which clarifies that they are stored in IEEE 754 format .

However it would probably be simpler and more future proof to send your data in a standard text format such as XML or JSON, both of which are supported by built-in functions in LabVIEW and standard library modules in Python.

A further reason not to use LabVIEW flattened data for exchange with other programs, if you have the choice, is that the flattened string doesn't include the type descriptor you need to convert it back into the original data type - you need to know what type the data was in order to decode it.

Answer 2

I wanted to document the problem and solution so others can hopefully avoid the hours I have wasted looking for a solution on google.

When LabVIEW flattens data, in this case a cluster of doubles, it sends them simply as a concatonated string with each double represented by 8 bytes. This is interpreted by python as 8 ASCII characters per double, which appears as nonsense in your console .

To get back to the transmitted doubles, you need to take each 8-byte section in turn and convert the ASCII characters to their ASCII codes, in Python's case using ord(). This will give you an 8 bytes of decimal codes (eg 4.8 = [64 19 51 51 51 51 51 51] )

It turns out that LabVIEW does most things, including TCP/IP transmissions, Big Endian. Unless you are working Big Endian, you will probably need to change it around. For example the example above will become [51 51 51 51 51 51 19 64] . I put each of my doubles into a list, so was able to use the list(reversed()) functions to change the endienness.

You can then convert this back to a double. Example python code:

import struct
b = bytearray([51,51,51,51,51,51,19,64]) #this is the number 4.8
value = struct.unpack('d', b)

print(value) #4.8

This is probably obvious to more experienced programmers, however it had me flummuxed for days. I apologise for using stackoverflow as the platform to share this by answering my own question, but hopefully this post helps the next person who is struggling.

EDIT: Note if you are using an earlier version than Python 2.7.5 then you might find struct.unpack() will fail. Using the example code above substituting the following code worked for me: b = bytes(bytearray([51,51,51,51,51,51,19,64]))

Answer 3

This code works for me. UDP server accept flattened dbl array x, return x+1 to port 6503. Modify LabView UDP client to your needs.

import struct
import socket
import numpy as np

def get_ip():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # doesn't even have to be reachable
        s.connect(('10.255.255.255', 1))
        IP = s.getsockname()[0]
    except:
        IP = '127.0.0.1'
    finally:
        s.close()
    return IP

#bind_ip = get_ip()

print("\n\n[*] Current ip is %s" % (get_ip()))
bind_ip = ''
bind_port = 6502

server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind((bind_ip,bind_port))  

print("[*] Ready to receive UDP on %s:%d" % (bind_ip,bind_port))

while True:
    data, address = server.recvfrom(1024)
    print('[*] Received %s bytes from %s:' % (len(data), address))

    arrLen = struct.unpack('>i', data[:4])[0]
    print('[*] Received array of %d doubles:' % (arrLen,))
    x = []
    elt = struct.iter_unpack('>d', data[4:])
    while True:
        try:
            x.append(next(elt)[0])
            print(x[-1])
        except StopIteration:
            break
    x = np.array(x)
    y = x+1 # np.sin(x)
    msg = data[:4]
    for item in y:
        msg += struct.pack('>d', item)
    print(msg)
    A = (address[0], 6503)
    server.sendto(msg, A)
    break

server.close()
print('[*] Server closed')
print('[*] Done')

LabView UDP client:

Answer 4

I understand that this does not solve your problem as you mentioned you didn't have the ability to modify the LabVIEW code. But, I was hoping to add some clarity on common ways string data is transmitted over TCP in LabVIEW.

The Endianness of the data string sent through the Write TCP can be controlled. I recommend using the Flatten To String Function as it gives you the ability to select which byte order you want to use when you flatten your data; big-endian (default if unwired), native (use the byte-order of the host machine), or little-endian.

Another common technique I've seen is using the Type Cast Function . Doing this will convert the numeric to a big-endian string. This of course can be confusing when you read it on the other end of the network as most everything else is little-endian, so you'll need to do some byte-swapping.

In general, if you're not sure what the code looks like, assume that it will be big-endian if its coming from LabVIEW code.

The answer from nekomatic is good one. Using a standard text format when available is always a good option.