如何在龙卷风中从websocket服务器向连接的客户端发送ros2消息

Question

我有一个ros2发布脚本，它从ros2节点发送自定义消息。我需要做的是让一个订阅者(这也是我的websocket服务器)侦听脉冲器发送的消息，然后将其转换为字典，并将它作为json从websocket服务器发送到连接的websocket客户端。我已经检查了架桥回购，但我无法使它工作。它没有足够的文档，而且我对ros还很陌生。我需要这样的东西：

import rclpy
import sys
from rclpy.node import Node
import tornado.ioloop

import tornado.httpserver
import tornado.web
import threading

from custom.msg import CustomMsg


from .convert import message_to_ordereddict





wss = []
class wsHandler(tornado.websocket.WebSocketHandler):
    def open(self):
        print 'Online'
        if self not in wss:
            wss.append(self)

    def on_close(self):
        print 'Offline'
        if self in wss:
            wss.remove(self)

def wsSend(message):
    for ws in wss:
        ws.write_message(message)


class MinimalSubscriber(Node):

    def __init__(self):
        super().__init__('minimal_subscriber')
        self.subscription = self.create_subscription(CustomMsg, 'topic', self.CustomMsg_callback, 10)
        self.subscription  # prevent unused variable warning

    def CustomMsg_callback(self, msg):
        ws_message = message_to_ordereddict(msg)
        wsSend(ws_message)






if __name__ == "__main__":
    http_server = tornado.httpserver.HTTPServer(tornado.web.Application(wsHandler))
    http_server.listen(8888)
    main_loop = tornado.ioloop.IOLoop.instance()
    # Start main loop
    main_loop.start()

因此，MinimalSubscriber类中的回调函数接收ros消息，将其转换为字典，并将其发送到websocket客户端。我有点困惑如何使这两个线程(ros和websocket)相互通信。

Answer 1

所以我想我有点迷茫了。因此，我改变了我的方法，并使它工作使用龙卷风周期回调和spin_once函数的rclpy作为回调函数。我会张贴我的解决方案，因为它可能会帮助一些人谁有相同的问题。

import queue
import rclpy
from rclpy.node import Node
import tornado.ioloop

import tornado.httpserver
import tornado.web


from custom.msg import CustomMsg


from .convert import message_to_ordereddict





wss = []
class wsHandler(tornado.websocket.WebSocketHandler):
    @classmethod
    def route_urls(cls):
        return [(r'/',cls, {}),]

    def open(self):
        print 'Online'
        if self not in wss:
            wss.append(self)

    def on_close(self):
        print 'Offline'
        if self in wss:
            wss.remove(self)


def make_app():
    myWebHandler = wsHandler.route_urls()
    return tornado.web.Application(myWebHandler)


message_queue = queue.Queue
class MinimalSubscriber(Node):

    def __init__(self):
        super().__init__('minimal_subscriber')
        self.subscription = self.create_subscription(CustomMsg, 'topic', self.CustomMsg_callback, 10)
        self.subscription  # prevent unused variable warning

    def CustomMsg_callback(self, msg):
        msg_dict = message_to_ordereddict(msg)
        msg_queue.put(msg_dict)






if __name__ == "__main__":
    rclpy.init(args=args)

    minimal_subscriber = MinimalSubscriber()


    def send_ros_to_clients():
        rclpy.spin_once(minimal_subscriber)
        my_msg = msg_queue.get()

        for client in ws_clients:
            client.write_message(my_msg)


    app = make_app()
    server = tornado.httpserver.HTTPServer(app)
    server.listen(8888)
    tornado.ioloop.PeriodicCallback(send_ros_to_clients, 1).start()
    tornado.ioloop.IOLoop.current().start()



    minimal_subscriber.destroy_node()
    rclpy.shutdown()

我还将wsSend函数实现为send_ros_to_clients函数。有些人可能会说，使用全局队列不是最佳实践，但我无法想出另一个解决方案。如对我的解决方案有任何建议或更正，我将不胜感激。