Cozmo人工智能机器人SDK使用笔记（5）-时序部分async_sync

Cozmo首先寻找一个立方体。 找到立方体后，立方体的灯以循环方式绿色闪烁，然后等待轻敲立方体。

此时，程序分别为同步和异步两种类型，注意区分。

1. 同步

立方体闪烁同步示例

      import asyncio
      import sys
      import cozmo
      class BlinkyCube(cozmo.objects.LightCube):
      '''Subclass LightCube and add a light-chaser effect.'''
      def __init__(self, *a, **kw):
       super().__init__(*a, **kw)
       self._chaser = None
      def start_light_chaser(self):
      '''Cycles the lights around the cube with 1 corner lit up green,
       changing to the next corner every 0.1 seconds.
       '''
      if self._chaser:
      raise ValueError("Light chaser already running")
      async def _chaser():
      while True:
      for i in range(4):
       cols = [cozmo.lights.off_light] * 4
       cols[i] = cozmo.lights.green_light
       self.set_light_corners(*cols)
      await asyncio.sleep(0.1, loop=self._loop)
       self._chaser = asyncio.ensure_future(_chaser(), loop=self._loop)
      def stop_light_chaser(self):
      if self._chaser:
       self._chaser.cancel()
       self._chaser = None
      # Make sure World knows how to instantiate the subclass
      cozmo.world.World.light_cube_factory = BlinkyCube
      def cozmo_program(robot: cozmo.robot.Robot):
       cube = None
       look_around = robot.start_behavior(cozmo.behavior.BehaviorTypes.LookAroundInPlace)
      try:
       cube = robot.world.wait_for_observed_light_cube(timeout=60)
      except asyncio.TimeoutError:
       print("Didn't find a cube :-(")
      return
      finally:
       look_around.stop()
       cube.start_light_chaser()
      try:
       print("Waiting for cube to be tapped")
       cube.wait_for_tap(timeout=10)
       print("Cube tapped")
      except asyncio.TimeoutError:
       print("No-one tapped our cube :-(")
      finally:
       cube.stop_light_chaser()
       cube.set_lights_off()
      cozmo.run_program(cozmo_program)
  
 

2. 异步

立方体闪烁异步示例

注意注释（效果相似但实现过程有差异）：

The async equivalent of 01_cube_blinker_sync.

    The usage of ``async def`` makes the cozmo_program method a coroutine.
    Within a coroutine, ``await`` can be used. With ``await``, the statement
    blocks until the request being waited for has completed. Meanwhile
    the event loop continues in the background.

    For instance, the statement
    ``await robot.world.wait_for_observed_light_cube(timeout=60)``
    blocks until Cozmo discovers a light cube or the 60 second timeout
    elapses, whichever occurs first.

    Likewise, the statement ``await cube.wait_for_tap(timeout=10)``
    blocks until the tap event is received or the 10 second timeout occurs,
    whichever occurs first.

    For more information, see
    https://docs.python.org/3/library/asyncio-task.html

      import asyncio
      import sys
      import cozmo
      class BlinkyCube(cozmo.objects.LightCube):
      '''Subclass LightCube and add a light-chaser effect.'''
      def __init__(self, *a, **kw):
       super().__init__(*a, **kw)
       self._chaser = None
      def start_light_chaser(self):
      '''Cycles the lights around the cube with 1 corner lit up green,
       changing to the next corner every 0.1 seconds.
       '''
      if self._chaser:
      raise ValueError("Light chaser already running")
      async def _chaser():
      while True:
      for i in range(4):
       cols = [cozmo.lights.off_light] * 4
       cols[i] = cozmo.lights.green_light
       self.set_light_corners(*cols)
      await asyncio.sleep(0.1, loop=self._loop)
       self._chaser = asyncio.ensure_future(_chaser(), loop=self._loop)
      def stop_light_chaser(self):
      if self._chaser:
       self._chaser.cancel()
       self._chaser = None
      # Make sure World knows how to instantiate the subclass
      cozmo.world.World.light_cube_factory = BlinkyCube
      async def cozmo_program(robot: cozmo.robot.Robot):
      '''The async equivalent of 01_cube_blinker_sync.
       The usage of ``async def`` makes the cozmo_program method a coroutine.
       Within a coroutine, ``await`` can be used. With ``await``, the statement
       blocks until the request being waited for has completed. Meanwhile
       the event loop continues in the background.
       For instance, the statement
       ``await robot.world.wait_for_observed_light_cube(timeout=60)``
       blocks until Cozmo discovers a light cube or the 60 second timeout
       elapses, whichever occurs first.
       Likewise, the statement ``await cube.wait_for_tap(timeout=10)``
       blocks until the tap event is received or the 10 second timeout occurs,
       whichever occurs first.
       For more information, see
       https://docs.python.org/3/library/asyncio-task.html
       '''
       cube = None
       look_around = robot.start_behavior(cozmo.behavior.BehaviorTypes.LookAroundInPlace)
      try:
       cube = await robot.world.wait_for_observed_light_cube(timeout=60)
      except asyncio.TimeoutError:
       print("Didn't find a cube :-(")
      return
      finally:
       look_around.stop()
       cube.start_light_chaser()
      try:
       print("Waiting for cube to be tapped")
      await cube.wait_for_tap(timeout=10)
       print("Cube tapped")
      except asyncio.TimeoutError:
       print("No-one tapped our cube :-(")
      finally:
       cube.stop_light_chaser()
       cube.set_lights_off()
      cozmo.run_program(cozmo_program)
  
 

Fin

文章来源: zhangrelay.blog.csdn.net，作者：zhangrelay，版权归原作者所有，如需转载，请联系作者。

原文链接：zhangrelay.blog.csdn.net/article/details/86672049