Question

我正在使用TCP / IP连接与激光对话并控制其功能。最初，我使用socket.connect（）方法将激光连接作为客户端，但激光和计算机都具有“相同的状态，因此两者都必须监视接收的传输以及发送请求”（如上所述）在TCP / IP协议手册中）。我如何知道配置/代码，以便即使我作为客户端连接，我也可以监控数据？我已经尝试在循环中使用recv（），但我不确定这是否正确。使用python 2.7

感谢您的帮助

安德鲁

import socket
import numpy as np
import json
import time


s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

def connect(IP_addrs = '192.168.1.222', port = 39933):
    s.settimeout(10)
    s.connect((IP_addrs,port))
    myIP = s.getsockname()[0]
    msg = {"transmission_id" : [1] , "op":"start_link", "parameters":{ "ip_address": myIP}}
    reply = send(msg)
    print reply

def send(msg):
    s.sendall( json.dumps( { "message" : msg } ) )
    r = s.recv(1024)
    r = json.loads(r)
    return r["message"]["parameters"]

def ping():
    msg = {'transmission_id' : [2], 'op':'ping', 'parameters':{'text_in':'TESTING'}}
    reply = send(msg)
    print reply['text_out']


def move_wave_m(wavelength):
    msg = {'transmission_id' : [3], 'op':'set_wave_m', 'parameters':{'wavelength': [wavelength],
           'report':['finished']}}
    reply = send(msg)
    print reply
    while True:
        reply = s.recv(1024)
        if not reply:
            break
        print reply

def poll_wave_m():
    msg = {'transmission_id' : [4], 'op':'poll_wave_m'}
    return send(msg)



connect()
ping()
s.settimeout(None)
move_wave_m(725.0000)
s.close()

Answer 1

我假设您使用的是Unix（Linux，Mac OS），但也有一些想法可以为Windows提出建议。这是一个程序的工作框架，它使用设备执行某些强制性操作，然后等待输入。在这种特殊情况下，我假装你想要实时访问激光（如终端访问）并同时观察响应。

import sys
import select
import socket

shell_is_active = True
sock = socket.socket()
# connect the socket


def do_mandatory_stuff():
    # sendall(...)
    pass


def interpret_user_input(user_input):
    # in case you want shell access to the laser
    print user_input


def main():
    do_mandatory_stuff()

    # wait for socket or user IO
    while shell_is_active:
        pending_inputs, _1, _2 = select.select([sys.stdin, sock], [], [], 0)
        if not pending_inputs:
            continue

        for input_source in pending_inputs:
            if input_source is sys.stdin:
                interpret_user_input(sys.stdin.readline())

            if input_source is sock:
                print sock.recv(1024)  # use more advanced things if needed

    sock.close()


if __name__ == '__main__':
    main()

这里至关重要的是select.select([sys.stdin, sock], [], [], 0) - 它是select的非阻塞调用，它返回一个描述符的列表，准备好阅读（pending_inputs），写作（_1）和其他条件（_2）。

如果需要在等待IO的同一个线程中完成一些后台工作，我会将其设置为非阻塞。否则，您可以随意删除0参数和随后的if阻止。

此行仅适用于类Unix系统（Linux，Mac OS）。为了使其适用于Windows，请使用select.select([sock], [], [], 0)。不幸的是，你必须在这个平台上创建一个单独的thread来捕获stdin。它可能看起来像这样：

import threading

sock_lock = threading.Lock()

def interpret_user_input():
    while True:
        inp = raw_input()
        with sock_lock:
            sock.sendall(inp)

...
def main():
    user_io_thread = threading.Thread(target=interpret_user_input)
    user_io_thread.run()

    # do mandatory stuff and then call select in a loop
    # don't forget "with sock_lock:" each time you use the socket!
    # (and other objects shared between threads as well)

监视数据的{TCP / IP}连接

1 个答案: