Question

我正在树莓派上构建一些硬件，在那里我有很多传感器和一堆执行器。我想使用Asyncio协同程序来连续监视多个传感器（从本质上讲，我不必从主循环中轮询），然后执行一堆执行器。

我打算为每个传感器创建一个类，该类在下面的代码中将具有像协程这样的方法。

我想将传感器方法的结果生成一个变量，然后可以对其进行操作。

我的问题是，如果我有多个协程写到一个地方，该如何安全地执行此操作。异步中的队列似乎是一对一的，而不是一对多的-正确吗？

最终我不明白如何让多个协程返回一个地方，具有一些逻辑，然后将消息发送给其他协程

+------------+
|            |                                +------------+
|  Sensor 1  +-------+                        |            |
|            |       |                    +--->  actuator1 |
+------------+       |                    |   |            |
                     |                    |   +------------+
+------------+       |      +-----------+ |
|            |       |      |           | |
|   Sensor 2 +------------> |  logic    +-+
|            |       |      |           | |
+------------+       |      +-----------+ |
                     |                    |   +------------+
+------------+       |                    |   |            |
|            |       |                    +--->  actuator2 |
|  Sensor 3  +-------+                        |            |
|            |                                +------------+
+------------+

以上内容代表了我正在努力实现的目标。我知道我可以通过轮询和while循环来实现，但是我喜欢尝试异步/事件驱动方法的想法。

import asyncio
import random

async def sensor(queue):
    while True:
        # Get some sensor data
        sensor_data = "data"

        await queue.put(sensor_data)


async def actuator(queue):
    while True:
        # wait for an item from the producer
        item = await queue.get()
        if item is None:
            # the producer emits None to indicate that it is done
            break

        # process the item
        print('consuming item {}...'.format(item))
        # simulate i/o operation using sleep
        await asyncio.sleep(random.random())

loop = asyncio.get_event_loop()
queue = asyncio.Queue(loop=loop)
sensor_coro = sensor(queue)
actuator_coro = actuator(queue)
loop.run_until_complete(asyncio.gather(sensor_coro, actuator_coro))
loop.close()

Answer 1

我的问题是，如果我有多个协程写到一个地方，该如何安全地执行此操作。异步中的队列似乎是一对一的，而不是一对多的-正确吗？

那是不正确的；异步队列是多生产者多消费者。要实现图的逻辑，您需要两个同步原语：

由sensor协程的多个实例填充并由logic()协程的单个实例耗尽的队列
一个附加的同步设备。这里哪种设备最好，取决于要求。例如，是否允许执行器“丢失”比其响应速度更快的消息？或者，logic应该等待吗？依靠它们，logic()和每个执行器之间的同步将是简单的Event（甚至只是Future）或另一个队列。

假设您为每个执行器使用一个队列，那么您的logic协程可能看起来像这样：

async def logic(sensor_queue, actuator_queues):
    while True:
        item = await queue.get()
        # process the item and signal some actuators
        await actuator_queues[0].put(x1)
        await actuator_queues[1].put(x2)

Answer 2

您可以考虑查看curio库。该文档对于理解异步编程模型非常有帮助，并且阅读起来很有趣。

对于您的特殊情况，我将研究Task Groups。这里有一个关于如何使用任务组等待任务以更高级的方式here返回的解释。

Python异步双向通信硬件控制

2 个答案: