1

我第一次在 python 中使用 asyncio 并尝试将它与 ZMQ 结合起来。

基本上我的问题是我有一个 REP/REQ 系统,其中async def有一个我需要等待的功能。如何不更新值。下面是一段代码来说明这一点:

#Declaring the zmq context
context = zmq_asyncio.Context()
REP_server_django = context.socket(zmq.REP)
REP_server_django.bind("tcp://*:5558")

我将这个对象发送到一个类并在这个函数中取回它

async def readsonar(self, trigger_pin, REP_server_django):
        i= 0
        while True:

            ping_from_view = await REP_server_django.recv()  # line.1
            value = await self.board.sonar_read(trigger_pin) # line.2
            print(value)                                     # line.3
            json_data = json.dumps(value)                    # line.4
            #json_data = json.dumps(i)                       # line.4bis
            REP_server_django.send(json_data.encode())       # line.5
            i+=1                                             # line.6
            await asyncio.sleep(1/1000)                      # line.7

,sonar_read正在使用 pymata_express 读取超声波传感器。如果我发表评论line.2并且line.4我得到正确的i. 如果我发表评论line.1line.5从. 但是,当我按此处所示运行它时,它没有更新。print(value)sonar_readvalue

我错过了什么吗?


编辑:
编辑了关于行注释的类型。我的意思是,如果我只读取声纳并打印值。它工作正常。如果我只有.recv()and .send(json.dumps(i).encode()),它的工作原理。但是,如果我尝试从声纳发送值。它锁定到value未更新的给定


EDIT2:(回答 Alan Yorinks):这是 MWE,它考虑了您发送的有关zmq课堂声明的内容。它取自pymata_express示例concurrent_tasks.py

要重现错误,请在两个不同的终端中运行这两个脚本。您将需要一个安装了Frimata_express的 arduino 板。如果一切运行良好, PART A.应该只在最后吐出相同的值mve_req.py。您可以编辑不同的块(部分 A、B 或 C)以查看行为。

mve_rep.py

#ADAPTED FROM PYMATA EXPRESS EXAMPLE CONCURRENTTAKS
#https://github.com/MrYsLab/pymata-express/blob/master/examples/concurrent_tasks.py
import asyncio
import zmq
import json
import zmq.asyncio as zmq_asyncio
from pymata_express.pymata_express import PymataExpress


class ConcurrentTasks:

    def __init__(self, board):


        self.loop = board.get_event_loop()
        self.board = board

        self.ctxsync = zmq.Context()
        self.context = zmq.asyncio.Context()
        self.rep = self.context.socket(zmq.REP)
        self.rep.bind("tcp://*:5558")

        self.trigger_pin = 53
        self.echo_pin = 51

        loop.run_until_complete(self.async_init_and_run())

    async def readsonar(self):
        i = 0
        while True:


            #PART. A. WHAT I HOPE COULD WORK
            rep_recv = await self.rep.recv()                       # line.1
            value = await self.board.sonar_read(self.trigger_pin)  # line.2
            print(value)                                           # line.3
            json_data = json.dumps(value)                          # line.4
            # json_data = json.dumps(i)                            # line.4bis
            await self.rep.send(json_data.encode())                # line.5
            i += 1                                                 # line.6
            await asyncio.sleep(1 / 1000)                          # line.7


            '''
            #PART. B. WORKS FINE IN UPDATING THE SONAR_RAED VALUE AND PRINTING IT
            value = await self.board.sonar_read(self.trigger_pin)  # line.2
            print(value)                                           # line.3
            json_data = json.dumps(value)                          # line.4
            i += 1                                                 # line.6
            await asyncio.sleep(1 / 1000)                          # line.7
            '''

            '''
            #PART. C. WORKS FINE IN SENDING THE i VALUE OVER ZMQ
            rep_recv = await self.rep.recv()                       # line.1
            json_data = json.dumps(i)                              # line.4bis
            await self.rep.send(json_data.encode())                # line.5
            i += 1                                                 # line.6
            await asyncio.sleep(1 / 1000)                          # line.7
            '''



    async def async_init_and_run(self):

        await self.board.set_pin_mode_sonar(self.trigger_pin, self.echo_pin)

        readsonar = asyncio.create_task(self.readsonar())
        await readsonar

        # OTHER CREATED_TASK GO HERE, (removed them in the MVE, but they work fine)


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    my_board = PymataExpress()
    try:
        ConcurrentTasks(my_board)
    except (KeyboardInterrupt, RuntimeError):
        loop.run_until_complete(my_board.shutdown())
        print('goodbye')
    finally:
        loop.close()

mve_req.py

import zmq
import time
import json

def start_zmq():
    context = zmq.Context()
    REQ_django  = context.socket(zmq.REQ)
    REQ_django.connect("tcp://localhost:5558")

    return REQ_django, context

def get_sonar(REQ_django):
    REQ_django.send(b"server_django")
    ping_from_server_django = REQ_django.recv()
    return ping_from_server_django.decode()

if __name__ == '__main__':

    data = {"sensors":{}}

    REQ_django, context = start_zmq()
    while REQ_django:

            data['sensors']['sonar'] = get_sonar(REQ_django)
            json_data = json.dumps(data)
            print(data)

            #DO OTHER WORK
            time.sleep(1)

    REQ_django.close()
    context.term()
4

4 回答 4

1

完全公开,我是pymata-expresspython-banyan 的作者。OP 要求我发布这个解决方案,所以这并不是一个无耻的插件。

自从在 Python 3 中首次引入 asyncio 以来,我一直在使用它进行开发。当 asyncio 代码工作时,asyncio(恕我直言)可以简化并发和代码。但是,当事情出错时,调试和了解问题的原因可能会令人沮丧。

我提前道歉,因为这可能有点冗长,但我需要提供一些背景信息,以便该示例看起来不像是一些随机的代码。

开发 python-banyan 框架是为了提供线程、多处理和异步的替代方案。简而言之,Banyan 应用程序由小型目标可执行文件组成,这些可执行文件使用通过 LAN 共享的协议消息相互通信。它的核心使用 Zeromq。它的设计目的不是让流量通过 WAN 移动,而是将 LAN 用作“软件背板”。在某些方面,Banyan 类似于 MQTT,但在 LAN 中使用时速度要快得多。如果需要,它确实能够连接到 MQTT 网络。

Banyan 的一部分是一个叫做 OneGPIO 的概念。它是一种协议消息规范,将 GPIO 功能抽象为独立于任何硬件实现。为了实现硬件细节,开发了专门的 Banyan 组件,称为 Banyan 硬件网关。有适用于 Raspberry Pi、Arduino、ESP-8266 和 Adafruit Crickit Hat 的网关。GPIO 应用程序发布任何或所有网关可以选择接收的通用 OneGPIO 消息。为了从一个硬件平台移动到另一个硬件平台,启动硬件关联网关,无需修改,启动控制组件(如下所示的代码)。从一个硬件平台到另一个硬件平台,任何组件都不需要修改代码,控制组件和网关都没有修改。变量,例如引脚号可以在启动控制组件时通过命令行选项指定。对于 Arduino 网关,pymata-express 用于控制 Arduino 的 GPIO。Pymata-express 是 StandardFirmata 客户端的异步实现。需要注意的是,下面的代码不是 asyncio。Banyan 框架允许使用适合问题的工具进行开发,但允许解耦部分解决方案,在这种情况下,应用程序允许将 asyncio 与 non-asyncio 混合,而不会遇到通常在做时遇到的任何麻烦所以。需要注意的是,下面的代码不是 asyncio。Banyan 框架允许使用适合问题的工具进行开发,但允许解耦部分解决方案,在这种情况下,应用程序允许将 asyncio 与 non-asyncio 混合,而不会遇到通常在做时遇到的任何麻烦所以。需要注意的是,下面的代码不是 asyncio。Banyan 框架允许使用适合问题的工具进行开发,但允许解耦部分解决方案,在这种情况下,应用程序允许将 asyncio 与 non-asyncio 混合,而不会遇到通常在做时遇到的任何麻烦所以。

在提供的代码中,类定义下面的所有代码都用于提供对命令行配置选项的支持。

import argparse
import signal
import sys
import threading
import time

from python_banyan.banyan_base import BanyanBase


class HCSR04(BanyanBase, threading.Thread):
    def __init__(self, **kwargs):
        """
        kwargs contains the following parameters
        :param back_plane_ip_address: If none, the local IP address is used
        :param process_name: HCSR04
        :param publisher_port: publishing port
        :param subscriber_port: subscriber port
        :param loop_time: receive loop idle time
        :param trigger_pin: GPIO trigger pin number
        :param echo_pin: GPIO echo pin number
        """

        self.back_plane_ip_address = kwargs['back_plane_ip_address'],
        self.process_name = kwargs['process_name']
        self.publisher_port = kwargs['publisher_port']
        self.subscriber_port = kwargs['subscriber_port'],
        self.loop_time = kwargs['loop_time']
        self.trigger_pin = kwargs['trigger_pin']
        self.echo_pin = kwargs['echo_pin']
        self.poll_interval = kwargs['poll_interval']

        self.last_distance_value = 0

        # initialize the base class
        super(HCSR04, self).__init__(back_plane_ip_address=kwargs['back_plane_ip_address'],
                                     subscriber_port=kwargs['subscriber_port'],
                                     publisher_port=kwargs['publisher_port'],
                                     process_name=kwargs['process_name'],
                                     loop_time=kwargs['loop_time'])

        threading.Thread.__init__(self)
        self.daemon = True

        self.lock = threading.Lock()

        # subscribe to receive messages from arduino gateway
        self.set_subscriber_topic('from_arduino_gateway')

        # enable hc-sr04 in arduino gateway
        payload = {'command': 'set_mode_sonar', 'trigger_pin': self.trigger_pin,
                   'echo_pin': self.echo_pin}
        self.publish_payload(payload, 'to_arduino_gateway')

        # start the thread
        self.start()

        try:
            self.receive_loop()
        except KeyboardInterrupt:
            self.clean_up()
            sys.exit(0)

    def incoming_message_processing(self, topic, payload):
        print(topic, payload)
        with self.lock:
            self.last_distance_value = payload['value']

    def run(self):
        while True:
            with self.lock:
                distance = self.last_distance_value
            payload = {'distance': distance}
            topic = 'distance_poll'
            self.publish_payload(payload, topic)
            time.sleep(self.poll_interval)


def hcsr04():
    parser = argparse.ArgumentParser()
    # allow user to bypass the IP address auto-discovery.
    # This is necessary if the component resides on a computer
    # other than the computing running the backplane.
    parser.add_argument("-b", dest="back_plane_ip_address", default="None",
                        help="None or IP address used by Back Plane")
    parser.add_argument("-i", dest="poll_interval", default=1.0,
                        help="Distance polling interval")
    parser.add_argument("-n", dest="process_name", default="HC-SRO4 Demo",
                        help="Set process name in banner")
    parser.add_argument("-p", dest="publisher_port", default="43124",
                        help="Publisher IP port")
    parser.add_argument("-s", dest="subscriber_port", default="43125",
                        help="Subscriber IP port")
    parser.add_argument("-t", dest="loop_time", default=".1",
                        help="Event Loop Timer in seconds")
    parser.add_argument("-x", dest="trigger_pin", default="12",
                        help="Trigger GPIO pin number")
    parser.add_argument("-y", dest="echo_pin", default="13",
                        help="Echo GPIO pin number")

    args = parser.parse_args()

    if args.back_plane_ip_address == 'None':
        args.back_plane_ip_address = None
    kw_options = {'back_plane_ip_address': args.back_plane_ip_address,
                  'publisher_port': args.publisher_port,
                  'subscriber_port': args.subscriber_port,
                  'process_name': args.process_name,
                  'loop_time': float(args.loop_time),
                  'trigger_pin': int(args.trigger_pin),
                  'echo_pin': int(args.echo_pin),
                  'poll_interval': int(args.poll_interval)
                  }

    # replace with the name of your class
    HCSR04(**kw_options)


# signal handler function called when Control-C occurs
def signal_handler(sig, frame):
    print('Exiting Through Signal Handler')
    raise KeyboardInterrupt


# listen for SIGINT
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGTERM, signal_handler)

if __name__ == '__main__':
    hcsr04()
于 2019-07-26T13:38:07.427 回答
0

(O/P MCVE 问题的定义更进一步——然而,无论是否优先考虑,{sensors|actors}-control-systems 的协调问题,使用分布式自治代理设计的系统在专业上都非常复杂且容易制作有缺陷的“快捷方式”或进入系统范围的阻塞状态

最好首先阅读有关ZeroMQ Hierarchy in less than 5 seconds以及有关相互死锁阻塞的内容阅读神话般的 Pieter HINTJENS 的书“代码 Connected: Volume 1" 对于任何系统设计人员来说都具有巨大的价值)

“......接缝很有趣,因为它已经实现了异步,所以我可以像我一样添加异步 zmq。我错了吗?”

是的,没有“只是添加异步”的捷径,控制系统是非常有趣的学科,而是一个复杂的学科。总是。很抱歉不得不直截了当地听到。在教科书示例或琐碎的创客项目中,用户可能会隐藏一些复杂性。然后,锤子会尝试通过添加一个或几个更琐碎的功能来扩展它们。复杂性突然浮出水面,这是前所未有的。


O/P 多代理[A,B,C,D]系统代码的形式图(原样)

将正式地图放在全屏编辑器上,以便查看所有相互冲突的依赖关系和竞争控制循环的更大图景。延迟是最容易的部分。无法解决的死锁阻塞风险的几个地方是核心之一。ZeroMQ,因为 v2.x 有工具可以避免其中一些,软件设计师有责任适当地减轻所有其他的。控制系统(机器人或其他)必须证明这种鲁棒性和对错误的弹性,并安全地“生存”所有“外部”事故。

最好的起点是第 1 行汇编语言指令中所表达的旧黄金法则:

;ASSUME NOTHING

并努力精心设计所有其余部分。


multi-agent-[A,B,C,D]-system coordination
             | | | |
             +-|-|-|--------------------- python while   ~ 100 [ms] GIL-lock enforced quota for pure-[SERIAL]-ised code-execution, imposed on all python-threads ( be it voluntarily or involuntarily interruped by the python GIL-lock mechanics, O/S-specific )
               +-|-|--------------------- hardware ~  64 - 147 [ms] self.board proxy-driven, responding to python code
                 +-|--------------------- python asynchronous, strict sequence of remote/local events dependent ZeroMQ dFSA, distributed among local-code operated REP and remote-code operated REQ-side(s) - enforcing a mutually ordered sequence of distributed behaviour as REQ/REP Scalable Formal Communication Archetype Pattern defines
                   +--------------------- python asyncio.get_event_loop() instantiated another event-loop that may permit to defer an execution(s) of some parts of otherwise imperative python-code to some later time

multi-agent-[A,B,C,D]-system code (as-is)
             : : : :
             : : : +---------------------------------------------------------+
             : : +-----------------------------------------------------------:-------------------+ - - - - - - - - - - - - - - - - -<?network?>- - - - - - - - - - - - - - +
             : +-------------------------------------------------------------:----------+        :                                                                         :
             :                                                               :          :        :                                                                         :
             :                                                               :          :        :                                                                         :
             !                                                               :          :        :                                                                         :
____PYTHON___!                                                               :          :        :                                                                         :
             !                                                               ?          ?        ?                                                                         ?
          +->!                                                              D?         B?       C?REP-1:{0:N}-remote---------------<?network?>------------------------REQ.C? dFSA-state?dependent
          ^  !                                                              D?         B?       C?REP-1:{0:N}                                                            .C?
          ^ A!: IMPERATIVE LOOP-HEAD: while True:                           D?AWAIT    B?       C?REP-1:{0:N}-distributed-Finite-State-Automaton (dFSA) BEHAVIOUR, local .C? side depends also on EVOLUTION OF A FUZZY, DYNAMIC, MULTIPARTY, network-wide dFSA-STATE(s) inside such ECOSYSTEM
          ^  !                                                              D?         B?       C?                                                                        
          ^  !                                                              D?         B?       C?                    REQ.C?-distributed-Finite-State-Automaton-STATE-REP.C?
          ^  !                                                              D?         B?       C?                       vC?                                             ^C?
          ^  !_______.SET DEFERRED:         P_D?C?_deferred_yield_ping     =D?await ...         C?REP.recv()---<--?---?--vC?-----<--<network>--------<--?remote-REQ-state-C?-( ^C?-dFSA-state && C?.recv()-blocking-mode of REQ/REP .recv()-waiting till a message, if any arrives error-free, blocks till then, just deferred via D?await )
          ^  !                                                              D?         B?                                vC?                                             ^C?
          ^  !_______.SET DEFERRED:         S_D?B?_deferred_yield_sonar    =D?await ...B?.board.sonar_read()-o-<--?-+    vC?                                             ^C?
          ^  !                                                                                               :      |    vC?                                             ^C?
          ^  !_______.GUI OUTPUT:           print( deferred_yield_sonar )  #A!->-----------------------------+->----?->---:?--->[ a last-known (if any) S_D?B?_deferred_yield_sonar value put "now" on GUI-screen ]
          ^  !                                                                                               :      ^    vC?                                             ^C?
          ^  !_______.SET TRANSFORMED:      S_D?B?_dependent_tranformed    =A!json.dumps( S_D?B? )--<--<--<--+      |    vC? <--[ a last-known (if any) S_D?B?_deferred_yield_sonar value transformed and assigned]
          ^  !                                                                                               :      |    vC?                                             ^C?
          ^  !_______.BLOCKING-MODE-SEND()  REP.send( S_D?B?_dependent_transformed.encode() )  #C? .send( S_D?B? )--?---->C?-->----<?network?>-->-------?remote-REQ-state-C?-( +C?-indeterministic and blocking-mode of REQ/REP .recv()-waiting till a message, if any arrives error-free, blocks till then )
          ^  !X:C?                                                                                                  ^    vC?                                             ^C?
          ^  !X:C?___.SET IMPERATIVE:       i += 1                                                                  | REQ.C?-distributed-Finite-State-Automaton-STATE-REP.C?
          ^  !X:C?                                                                                                  ?                                                       
          ^  !X:C?___.NOP/SLEEP() DEFERRED: await sleep( ... )             #D?AWAIT                                 ^                                                      :
          ^  !X:C?D?+0ms                                                                                            |                                                      :
          ^  !X:C?D?_.JUMP/LOOP                                                                                     ?                                                      :
          ^__!X:C?D?+0ms                                                                                            ^                                                      :
                                                                                                                    |                                                      :
                                                                                                                    |                                                      :
                                                                                                                    |                                                      :
____SONAR___________________________________________________________________________________________________________B? REQUEST T0: + EXPECT ~64 - ~147 [ms] LATENCY        :
                                                                                                                    B? hardware value acquisition latency can be masked    :
                                                                                                                       via await or other concurrency-trick )              :
                                                                                                                                                                           :
____REQ-side(s)_?{0:N} __________________________________________________________________________________________________________________________________________________^C? dFSA-remote autonomous-agent outside-of-CodeBlock-scope-of-control + behind <?network?>
_____REQ-side(s)_?{0:N} _________________________________________________________________________________________________________________________________________________^C? dFSA-remote autonomous-agent outside-of-CodeBlock-scope-of-control + behind <?network?>
______REQ-side(s)_?{0:N} ________________________________________________________________________________________________________________________________________________^C? dFSA-remote autonomous-agent outside-of-CodeBlock-scope-of-control + behind <?network?>
_______REQ-side(s)_?{0:N} _______________________________________________________________________________________________________________________________________________^C? dFSA-remote autonomous-agent outside-of-CodeBlock-scope-of-control + behind <?network?>
     ...                                                                                                                                                                 ::: ...
______...REQ-side(s)_?{0:N} _____________________________________________________________________________________________________________________________________________^C? dFSA-remote autonomous-agent outside-of-CodeBlock-scope-of-control + behind <?network?>

正如 O/P 的EDIT : 2 小时前解释的那样,

问题现在很明显。无限while True:循环指示硬单步执行,逐行循环,然后一个接一个地再次循环“旋转”所有步骤,而任何asyncio await存在的装饰函子都被留下,异步独立于这个“主" A:while True:命令式代码执行的循环块。同理 a B:self.board -device 的外部 sonar-device 是独立定时设备,在 python 代码外部,有一些难以管理的硬件/读取/解码延迟,固定循环的协调 + C: ZeroMQ - REQ/REP-Archetype-behaviour (再次与分散的“外国”进行外部协调REQ-actor(s)/agent(s) - 是的,你不知道,其中有多少...... - 但所有这些都超出了你的控制范围,所有REQ-side(s) 和你的本地实例化REP-side 分布式有限状态机状态完全独立于“框架”-python 循环的意愿来推动步骤并执行下一步,下一步,下一步......)+另一个,这里是D:asyncio.get_event_loop() - 实例化的“第三个”-event_loop,这会影响await-decorated 仿函数实际上是如何被允许延迟产生结果并在以后交付它们的 ----- 而且,这就是“交叉面包”的问题 -事件循环。

如果这个问题设置是由任何计算机科学教授详细阐述的,那么她/他应该为使该任务成为分布式系统问题的最佳示例而受到起立鼓掌 - 几乎可以作为对 Margaret HAMILTON 夫人在正确设计 Apollo 方面的工作的致敬AGC 计算机系统,她的工作解决了这类问题,从而挽救了机组人员的生命和 50 年前登月的所有骄傲。很棒的演讲,汉密尔顿夫人,很棒的演讲。

微不足道,但就在现场。

确实是一项可爱且科学上奇妙的任务:为一组独立定时和操作的代理(一种命令式解释 python 语言)

设计一个健壮、抗故障和协调工作的策略,主要是让GIL 锁防止零并发,但是纯流程流,是半持久网络分布式代理的模糊集合,是独立操作的硬件设备,具有与可检查代理的一些有限 I/O 接口,并且所有这些都相互独立并物理分布在给定的生态系统中软件、硬件和网络。[A, B, C, D], A[SERIAL]CREQ/REPBAself.board

昨天已经提出了硬件诊断 + 提议的系统架构方法。在不测试self.board托管声纳设备延迟的情况下,没有人可以决定下一个最佳步骤,因为现实的(体内基准测试)硬件响应时间(+最好的文档还包括.board它的外围传感器设备 MUX-编辑与否?PRIO 驱动或 MUTEX 锁定或静态、非共享外围设备、寄存器只读抽象,...?)是决定可能的[A, B, C, D]协调策略的关键。


ZeroMQ 部分:

如果您发表评论l.5-REP_server_django.send(json_data.encode()) # l.5您将进入最后一个块,因为REQ/REPZeroMQ 可扩展正式通信原型模式的原始严格形式不能再次,如果它在收到第一个后.recv()没有回复到REQ-side 之后。.recv().send()

这是一个简单的问题。


其余的不是可重现的代码。

您可能想要:

  • 验证是否self.board.sonar_read( trigger_pin )收到任何值并测试这样做的延迟:

   import numpy as np
   from zmq import Stopwatch
   aClk = Stopwatch()

   def sonarBeep():
       try:
            a_value   = -1
            aClk.start()
            a_value   = self.board.sonar_read( trigger_pin )
            a_time_us = aClk.stop()
       except:
            try:
                aClk.stop()
            finally:
                a_time_us = -1
       finally:
           return( a_value, a_time_us )

并运行一系列 100 次声纳测试,以获得关于延迟时间的min、Avg、StDev、MAX读数,[us]因为这些值是需要知道的,以防要根据 SONAR 传感器数据设计一些控制回路。

[ aFun( [ sonarBeep()[1] for _    in range( 100 ) ]
        )                for aFun in ( np.min, np.mean, np.std, np.max )
  ]

系统架构和子系统协调:

最后但并非最不重要的一点是,可以让读取和存储声纳数据,在一个绝对独立的事件循环中,不与任何其他操作协调,只从这样的存储中读取一个状态变量,设置在一个独立工作的子系统中(如果不是非常作为独立的系统行为来节省电力)

每当尝试紧密协调独立事件流(在具有不协调或弱协调代理的分布式系统中最糟糕的事件)时,设计必须在对错误的鲁棒性、时间错位和错误恢复能力方面都提高。否则系统可能很快就会死锁/活锁。

如果有疑问,可以从 XEROX Palo Alto 研究中心 MVC 分离的原始哲学中学习,其中MODEL-part 可以(并且大部分时间在 GUI 框架中,因为 198x+ 确实如此)接收许多独立更新的状态变量其他系统组件,它们只是在需要时读取/使用实际状态变量的数据。类似地,如果功率预算允许,SONAR 可以连续扫描场景并将读数写入任何本地寄存器,并让其他组件来询问或接受他们对最后一次实际 SONAR 读数的请求。

ZeroMQ 零之零工作也是如此。

如果这可能有帮助,请检查以zmq.CONFLATE这种方式正常工作的本地消息存储的模式。

一个小提示:人们可能已经注意到,这sleep( 1 / 1000 )是一个相当昂贵、重复执行的步骤并且很危险,因为它在 py2.x 中实际上没有睡眠,因为整数除法。

于 2019-07-23T23:20:05.130 回答
0

我不确定这是否会解决您的问题,但我确实发现了一些潜在的问题。

  1. 目前尚不清楚如何调用 readsonar。
  2. 上下文的创建有一个错字。
  3. 不等待 REP_server_django.send。

以下是我对代码的返工(未经测试):

import asyncio
import zmq
import json


class Play:
    def __init__(self):
        self.context = zmq.asyncio.Context()
        self.REP_server_django = self.context.socket(zmq.REP)
        self.REP_server_django.bind("tcp://*:5558")
        self.event_loop = asyncio.get_event_loop()
        self.event_loop.run_until_complete(self.readsonar(4))

    async def readsonar(self, trigger_pin):
        i = 0
        while True:
            ping_from_view = await self.REP_server_django.recv()  # l.1
            value = await self.board.sonar_read(trigger_pin)  # l.2
            print(value)  # l.3
            json_data = json.dumps(value)  # l.4
            # json_data = json.dumps(i) # l.4bis
            await self.REP_server_django.send(json_data.encode())  # l.5
            i += 1  # l.6
            await asyncio.sleep(1 / 1000)  # l.6
于 2019-07-23T23:36:42.570 回答
0

我让它工作了,虽然我不得不承认,我不明白它为什么工作的原因。基本上我必须做一个新的async def,它只轮询读数sonar_read并用于asyncio.wait返回值。这是代码:

#ADAPTED FROM PYMATA EXPRESS EXAMPLE CONCURRENTTAKS
#https://github.com/MrYsLab/pymata-express/blob/master/examples/concurrent_tasks.py
import asyncio
import zmq
import json
import zmq.asyncio as zmq_asyncio
from pymata_express.pymata_express import PymataExpress


class ConcurrentTasks:

    def __init__(self, board):


        self.loop = board.get_event_loop()
        self.board = board

        self.ctxsync = zmq.Context()
        self.context = zmq.asyncio.Context()
        self.rep = self.context.socket(zmq.REP)
        self.rep.bind("tcp://*:5558")

        self.trigger_pin = 53
        self.echo_pin = 51

        loop.run_until_complete(self.async_init_and_run())

    ### START:  NEW CODE THAT RESOLVED THE ISSUE
    async def pingsonar(self):
        value = await self.board.sonar_read(self.trigger_pin)
        return value

    async def readsonar(self):
        while True:
            rep_recv = await self.rep.recv() 
            value = await asyncio.wait([self.pingsonar()])
            valuesonar = list(value[0])[0].result()
            json_data = json.dumps(valuesonar) 
            await self.rep.send(json_data.encode()) 
            await asyncio.sleep(1 / 1000) #maybe this line isn't necessary

    ### END : NEW CODE THAT RESOLVED THE ISSUE

    async def async_init_and_run(self):

        await self.board.set_pin_mode_sonar(self.trigger_pin, self.echo_pin)

        readsonar = asyncio.create_task(self.readsonar())
        await readsonar

        # OTHER CREATED_TASK GO HERE, (removed them in the MVE, but they work fine)


if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    my_board = PymataExpress()
    try:
        ConcurrentTasks(my_board)
    except (KeyboardInterrupt, RuntimeError):
        loop.run_until_complete(my_board.shutdown())
        print('goodbye')
    finally:
        loop.close()

尽管如此,我仍然感谢您的帮助。

于 2019-07-25T21:40:42.570 回答