├── test ├── __init__.py ├── simple_socket-0.0.2-py3-none-any.whl ├── tts_demo │ ├── dist │ │ ├── tts_demo-0.0.2.tar.gz │ │ └── tts_demo-0.0.2-py3-none-any.whl │ ├── play_tts │ │ ├── __init__.py │ │ └── test_playTTS.py │ └── setup.py ├── test_future.py ├── test_pkg_tool.py ├── test_wifi_browser.py ├── demo_face_detect.py ├── demo_infrared.py ├── demo_face_recognize.py ├── test_connect.py ├── demo_touch.py ├── demo_robot_posture.py ├── test_content.py ├── demo_speech_recognize.py ├── test_action.py ├── test_pkg_tool_upload_script.py ├── test_expression.py ├── test_event.py ├── test_sound.py └── test_sence.py ├── README.md ├── .gitignore └── LICENSE /test/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # mini_demo 2 | alpha mini robot python sdk demo 3 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /build 2 | __pycache__ 3 | /.idea 4 | /venv 5 | /alphamini.egg-info 6 | /dist -------------------------------------------------------------------------------- /test/simple_socket-0.0.2-py3-none-any.whl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marklogg/mini_demo/HEAD/test/simple_socket-0.0.2-py3-none-any.whl -------------------------------------------------------------------------------- /test/tts_demo/dist/tts_demo-0.0.2.tar.gz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marklogg/mini_demo/HEAD/test/tts_demo/dist/tts_demo-0.0.2.tar.gz -------------------------------------------------------------------------------- /test/tts_demo/play_tts/__init__.py: -------------------------------------------------------------------------------- 1 | from .test_playTTS import * 2 | 3 | name = "tts_demo" 4 | 5 | __all__ = { 6 | 'test_playTTS', 7 | } 8 | -------------------------------------------------------------------------------- /test/tts_demo/dist/tts_demo-0.0.2-py3-none-any.whl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/marklogg/mini_demo/HEAD/test/tts_demo/dist/tts_demo-0.0.2-py3-none-any.whl -------------------------------------------------------------------------------- /test/test_future.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | import functools 3 | 4 | 5 | def callback(future, n): 6 | print('{}: future done: {}'.format(n, future.result())) 7 | 8 | 9 | async def register_callbacks(fut): 10 | print('registering callbacks on future') 11 | fut.add_done_callback(functools.partial(callback, n=1)) 12 | fut.add_done_callback(functools.partial(callback, n=2)) 13 | 14 | 15 | async def main(fut): 16 | await register_callbacks(fut) 17 | print(f'{fut}') 18 | print('setting result of future') 19 | fut.set_result('the result') 20 | 21 | 22 | event_loop = asyncio.get_event_loop() 23 | try: 24 | all_done = asyncio.Future() 25 | event_loop.run_until_complete(main(all_done)) 26 | finally: 27 | event_loop.close() 28 | -------------------------------------------------------------------------------- /test/tts_demo/play_tts/test_playTTS.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini import mini_sdk as MiniSdk 4 | from mini.apis.api_sound import StartPlayTTS 5 | from mini.mini_sdk import WiFiDevice 6 | 7 | 8 | async def _play_tts(): 9 | block: StartPlayTTS = StartPlayTTS(text="你好， 我是悟空，测试测试，啦啦啦") 10 | # 返回元组, response是个ControlTTSResponse 11 | (resultType, response) = await block.execute() 12 | print(f'{response}') 13 | 14 | 15 | async def _run(): 16 | device: WiFiDevice = await MiniSdk.get_device_by_name("0090", 10) 17 | if device: 18 | await MiniSdk.connect(device) 19 | await MiniSdk.enter_program() 20 | await _play_tts() 21 | await MiniSdk.quit_program() 22 | await MiniSdk.release() 23 | 24 | 25 | def main(): 26 | asyncio.run(_run()) 27 | 28 | 29 | if __name__ == '__main__': 30 | main() 31 | -------------------------------------------------------------------------------- /test/tts_demo/setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # coding=utf-8 3 | 4 | import setuptools 5 | 6 | setuptools.setup( 7 | name="tts_demo", 8 | version="0.0.2", 9 | author='Gino Deng', 10 | author_email='jingjing.deng@ubtrobot.com', 11 | description="demo with mini_sdk", 12 | long_description='demo with mini_sdk,xxxxxxx', 13 | long_description_content_type="text/markdown", 14 | license="GPLv3", 15 | packages=setuptools.find_packages(), 16 | classifiers=[ 17 | "Programming Language :: Python :: 3", 18 | "Programming Language :: Python :: 3.6", 19 | "Programming Language :: Python :: 3.7", 20 | "Programming Language :: Python :: 3.8", 21 | "License :: OSI Approved :: MIT License", 22 | "Operating System :: OS Independent", 23 | ], 24 | install_requires=[ 25 | 'alphamini > 0.1.3', 26 | ], 27 | entry_points={ 28 | 'console_scripts': [ 29 | 'tts_demo = play_tts.test_playTTS:main' 30 | ], 31 | }, 32 | zip_safe=False 33 | ) 34 | -------------------------------------------------------------------------------- /test/test_pkg_tool.py: -------------------------------------------------------------------------------- 1 | import mini.pkg_tool as Tool 2 | 3 | robot_id = "0090" 4 | 5 | if __name__ == '__main__': 6 | # 查询alphamini包信息 7 | # info = Tool.query_py_pkg(pkg_name="alphamini", robot_id=robot_id) 8 | # print(f'{info}') 9 | # 10 | # # 列出机器人内py包 11 | # list_info = Tool.list_py_pkg(robot_id=robot_id) 12 | # print(f'{list_info}') 13 | # 14 | # # 安装当前目录下simple_socket-0.0.2-py3-none-any.whl文件 15 | # Tool.install_py_pkg(package_path="simple_socket-0.0.2-py3-none-any.whl", robot_id=robot_id, debug=True) 16 | # # 卸载simple_socket 17 | # Tool.uninstall_py_pkg(pkg_name="simple-socket", robot_id=robot_id, debug=True) 18 | 19 | # 将当前目录下的tts_demo工程打包成py wheel， 返回值为打包生成后的wheel路径 20 | pkg_path = Tool.setup_py_pkg("tts_demo") 21 | print(f'{pkg_path}') 22 | 23 | # 卸载tts_demo 24 | Tool.uninstall_py_pkg(pkg_name="tts_demo", robot_id=robot_id) 25 | 26 | # 重新安装打包后的tts_demo 27 | Tool.install_py_pkg(package_path=pkg_path, robot_id=robot_id, debug=False) 28 | 29 | # 触发tts_demo脱机执行 30 | Tool.run_py_pkg("tts_demo", robot_id=robot_id) 31 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 marklogg 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /test/test_wifi_browser.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import asyncio 4 | 5 | from mini.dns.dns_browser import WiFiDeviceListener, WiFiDevice 6 | 7 | 8 | class MyDeviceListener(WiFiDeviceListener): 9 | 10 | def on_device_updated(self, device: WiFiDevice) -> None: 11 | pass 12 | 13 | def on_device_removed(self, device: WiFiDevice) -> None: 14 | pass 15 | 16 | def on_device_found(self, device: WiFiDevice): 17 | print(self, "onDeviceFound:", device) 18 | 19 | 20 | listener = MyDeviceListener() 21 | 22 | listener2 = MyDeviceListener() 23 | 24 | from mini.channels.websocket_client import ubt_websocket as SocketClient 25 | 26 | print(f'{SocketClient()}') 27 | 28 | from mini.dns.dns_browser import browser 29 | 30 | 31 | async def test_browser(): 32 | browser().add_listener(listener) 33 | browser().add_listener(listener2) 34 | browser().remove_listener(None) 35 | browser().remove_all_listener() 36 | browser().start_scan(10000) 37 | await asyncio.sleep(10) 38 | try: 39 | input("Press enter to exit...\n\n") 40 | finally: 41 | browser().stop_scan() 42 | exit() 43 | 44 | 45 | asyncio.get_event_loop().run_until_complete(test_browser()) 46 | -------------------------------------------------------------------------------- /test/demo_face_detect.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis.api_observe import ObserveFaceDetect 4 | from mini.apis.api_sound import StartPlayTTS 5 | from mini.dns.dns_browser import WiFiDevice 6 | from mini.pb2.codemao_facedetecttask_pb2 import FaceDetectTaskResponse 7 | from test.test_connect import test_connect, shutdown 8 | from test.test_connect import test_get_device_by_name, test_start_run_program 9 | 10 | 11 | async def test_ObserveFaceDetect(): 12 | """人脸个数检测demo 13 | 14 | 人脸个数检测,检测到人脸,则上报事件 15 | 16 | 当检测到人脸个数大于等于1个时，停止监听，并播报"在我面前好像有xx个人脸"(xx为人脸个数) 17 | 18 | """ 19 | observer: ObserveFaceDetect = ObserveFaceDetect() 20 | 21 | # FaceDetectTaskResponse.count 22 | # FaceDetectTaskResponse.isSuccess 23 | # FaceDetectTaskResponse.resultCode 24 | def handler(msg: FaceDetectTaskResponse): 25 | print(f"{msg}") 26 | if msg.isSuccess and msg.count: 27 | observer.stop() 28 | asyncio.create_task(__tts(msg.count)) 29 | 30 | observer.set_handler(handler) 31 | observer.start() 32 | await asyncio.sleep(0) 33 | 34 | 35 | async def __tts(count): 36 | await StartPlayTTS(text=f'在我面前好像有{count}个人').execute() 37 | asyncio.get_running_loop().run_in_executor(None, asyncio.get_running_loop().stop) 38 | 39 | 40 | if __name__ == '__main__': 41 | device: WiFiDevice = asyncio.get_event_loop().run_until_complete(test_get_device_by_name()) 42 | if device: 43 | asyncio.get_event_loop().run_until_complete(test_connect(device)) 44 | asyncio.get_event_loop().run_until_complete(test_start_run_program()) 45 | asyncio.get_event_loop().run_until_complete(test_ObserveFaceDetect()) 46 | # 定义了事件监听对象,必须让event_loop.run_forver() 47 | asyncio.get_event_loop().run_forever() 48 | asyncio.get_event_loop().run_until_complete(shutdown()) 49 | -------------------------------------------------------------------------------- /test/demo_infrared.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis.api_observe import ObserveInfraredDistance 4 | from mini.apis.api_sound import StartPlayTTS 5 | from mini.dns.dns_browser import WiFiDevice 6 | from mini.pb2.codemao_observeinfrareddistance_pb2 import ObserveInfraredDistanceResponse 7 | from test.test_connect import test_connect, shutdown 8 | from test.test_connect import test_get_device_by_name, test_start_run_program 9 | 10 | 11 | async def test_ObserveInfraredDistance(): 12 | """监听红外距离demo 13 | 14 | 监听红外距离事件，机器人上报检测到的与面前最近障碍物的红外距离 15 | 16 | 当返回的红外距离小于500，停止监听，并播报"检测到红外距离xxx"(xxx是红外距离数值) 17 | 18 | """ 19 | # 红外监听对象 20 | observer: ObserveInfraredDistance = ObserveInfraredDistance() 21 | 22 | # 定义处理器 23 | # ObserveInfraredDistanceResponse.distance 24 | def handler(msg: ObserveInfraredDistanceResponse): 25 | print("distance = {0}".format(str(msg.distance))) 26 | if msg.distance < 500: 27 | observer.stop() 28 | asyncio.create_task(__tts(msg.distance)) 29 | 30 | observer.set_handler(handler) 31 | observer.start() 32 | await asyncio.sleep(0) 33 | 34 | 35 | async def __tts(distance: int): 36 | result = await StartPlayTTS(text=f"检测到红外距离{distance}").execute() 37 | print(f"tts over {result}") 38 | asyncio.get_running_loop().run_in_executor(None, asyncio.get_running_loop().stop) 39 | 40 | 41 | if __name__ == '__main__': 42 | device: WiFiDevice = asyncio.get_event_loop().run_until_complete(test_get_device_by_name()) 43 | if device: 44 | asyncio.get_event_loop().run_until_complete(test_connect(device)) 45 | asyncio.get_event_loop().run_until_complete(test_start_run_program()) 46 | asyncio.get_event_loop().run_until_complete(test_ObserveInfraredDistance()) 47 | # 定义了事件监听对象,必须让event_loop.run_forver() 48 | asyncio.get_event_loop().run_forever() 49 | asyncio.get_event_loop().run_until_complete(shutdown()) 50 | -------------------------------------------------------------------------------- /test/demo_face_recognize.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis.api_observe import ObserveFaceRecognise 4 | from mini.apis.api_sound import StartPlayTTS 5 | from mini.dns.dns_browser import WiFiDevice 6 | from mini.pb2.codemao_facerecognisetask_pb2 import FaceRecogniseTaskResponse 7 | from test.test_connect import test_connect, shutdown 8 | from test.test_connect import test_get_device_by_name, test_start_run_program 9 | 10 | 11 | # 测试, 检测到注册的人脸,则上报事件, 如果陌生人,返回"stranger" 12 | async def test_ObserveFaceRecognise(): 13 | """人脸识别demo 14 | 15 | 监听人脸识别事件，机器人上报识别到的人脸信息(数组) 16 | 17 | 如果是已注册的人脸，返回人脸详细信息：id，名字，性别，年龄 18 | 19 | 如果是陌生人，返回 name: "stranger" 20 | 21 | 当成功识别到人脸后，停止监听，播报"你好，xxx"(xxx为人脸信息中的name) 22 | 23 | """ 24 | observer: ObserveFaceRecognise = ObserveFaceRecognise() 25 | 26 | # FaceRecogniseTaskResponse.faceInfos: [FaceInfoResponse] 27 | # FaceInfoResponse.id, FaceInfoResponse.name,FaceInfoResponse.gender,FaceInfoResponse.age 28 | # FaceRecogniseTaskResponse.isSuccess 29 | # FaceRecogniseTaskResponse.resultCode 30 | def handler(msg: FaceRecogniseTaskResponse): 31 | print(f"{msg}") 32 | if msg.isSuccess and msg.faceInfos: 33 | observer.stop() 34 | asyncio.create_task(__tts(msg.faceInfos[0].name)) 35 | 36 | observer.set_handler(handler) 37 | observer.start() 38 | await asyncio.sleep(0) 39 | 40 | 41 | async def __tts(name): 42 | await StartPlayTTS(text=f'你好， {name}').execute() 43 | asyncio.get_running_loop().run_in_executor(None, asyncio.get_running_loop().stop) 44 | 45 | 46 | if __name__ == '__main__': 47 | device: WiFiDevice = asyncio.get_event_loop().run_until_complete(test_get_device_by_name()) 48 | if device: 49 | asyncio.get_event_loop().run_until_complete(test_connect(device)) 50 | asyncio.get_event_loop().run_until_complete(test_start_run_program()) 51 | asyncio.get_event_loop().run_until_complete(test_ObserveFaceRecognise()) 52 | # 定义了事件监听对象,必须让event_loop.run_forver() 53 | asyncio.get_event_loop().run_forever() 54 | asyncio.get_event_loop().run_until_complete(shutdown()) 55 | -------------------------------------------------------------------------------- /test/test_connect.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | import logging 3 | 4 | import mini.mini_sdk as MiniSdk 5 | from mini.dns.dns_browser import WiFiDevice 6 | 7 | 8 | # 搜索指定序列号(在机器人屁股后面)的机器人, 可以只输入序列号尾部字符即可,长度任意, 建议5个字符以上可以准确匹配, 10秒超时 9 | # 搜索的结果WiFiDevice, 包含机器人名称,ip,port等信息 10 | async def test_get_device_by_name(): 11 | """根据机器人序列号后缀搜索设备 12 | 13 | 搜索指定序列号(在机器人屁股后面)的机器人, 可以只输入序列号尾部字符即可,长度任意, 建议5个字符以上可以准确匹配, 10秒超时 14 | 15 | 16 | Returns: 17 | WiFiDevice: 包含机器人名称,ip,port等信息 18 | 19 | """ 20 | result: WiFiDevice = await MiniSdk.get_device_by_name("00879", 10) 21 | print(f"test_get_device_by_name result:{result}") 22 | return result 23 | 24 | 25 | # 搜索指定序列号(在机器人屁股后面)的机器人, 26 | async def test_get_device_list(): 27 | """搜索所有设备 28 | 29 | 搜索所有设备，10s后返回结果 30 | 31 | Returns: 32 | [WiFiDevice]: 所有搜索到的设备，WiFiDevice数组 33 | 34 | """ 35 | results = await MiniSdk.get_device_list(10) 36 | print(f"test_get_device_list results = {results}") 37 | return results 38 | 39 | 40 | # MiniSdk.connect 返回值为bool, 这里忽略返回值 41 | async def test_connect(dev: WiFiDevice) -> bool: 42 | """连接设备 43 | 44 | 连接指定的设备 45 | 46 | Args: 47 | dev (WiFiDevice): 指定的设备对象 WiFiDevice 48 | 49 | Returns: 50 | bool: 是否连接成功 51 | 52 | """ 53 | return await MiniSdk.connect(dev) 54 | 55 | 56 | # 进入编程模式,机器人有个tts播报,这里通过asyncio.sleep 让当前协程等6秒返回,让机器人播完 57 | async def test_start_run_program(): 58 | """进入编程模式demo 59 | 60 | 使机器人进入编程模式，等待回复结果，并延时6秒，让机器人播完"进入编程模式" 61 | 62 | Returns: 63 | None: 64 | 65 | """ 66 | await MiniSdk.enter_program() 67 | 68 | 69 | # 断开连接并释放资源 70 | async def shutdown(): 71 | """断开连接并释放资源 72 | 73 | 断开当前连接的设备，并释放资源 74 | 75 | """ 76 | await MiniSdk.quit_program() 77 | await MiniSdk.release() 78 | 79 | 80 | # 默认的日志级别是Warning, 设置为INFO 81 | MiniSdk.set_log_level(logging.INFO) 82 | # 设置机器人类型 83 | MiniSdk.set_robot_type(MiniSdk.RobotType.DEDU) 84 | 85 | 86 | async def main(): 87 | device: WiFiDevice = await test_get_device_by_name() 88 | if device: 89 | await test_connect(device) 90 | await shutdown() 91 | 92 | 93 | if __name__ == '__main__': 94 | asyncio.run(main()) 95 | -------------------------------------------------------------------------------- /test/demo_touch.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis.api_behavior import StartBehavior 4 | from mini.apis.api_observe import ObserveHeadRacket, HeadRacketType 5 | from mini.dns.dns_browser import WiFiDevice 6 | from mini.pb2.codemao_observeheadracket_pb2 import ObserveHeadRacketResponse 7 | from test.test_connect import test_connect, shutdown 8 | from test.test_connect import test_get_device_by_name, test_start_run_program 9 | 10 | 11 | # 测试, 触摸监听 12 | async def test_ObserveHeadRacket(): 13 | """监听拍头事件demo 14 | 15 | 监听拍头事件，当机器人头部被拍击时，上报拍头类型 16 | 17 | 当机器人头部被双击时，停止监听，并跳一个舞蹈 18 | 19 | # ObserveHeadRacketResponse.type: 20 | 21 | # class HeadRacketType(enum.Enum): 22 | 23 | # SINGLE_CLICK = 1 # 单击 24 | 25 | # LONG_PRESS = 2 # 长按 26 | 27 | # DOUBLE_CLICK = 3 # 双击 28 | 29 | """ 30 | # 创建监听 31 | observer: ObserveHeadRacket = ObserveHeadRacket() 32 | 33 | # 事件处理器 34 | # ObserveHeadRacketResponse.type: 35 | # @enum.unique 36 | # class HeadRacketType(enum.Enum): 37 | # SINGLE_CLICK = 1 # 单击 38 | # LONG_PRESS = 2 # 长按 39 | # DOUBLE_CLICK = 3 # 双击 40 | def handler(msg: ObserveHeadRacketResponse): 41 | # 监听到一个事件后,停止监听, 42 | print("{0}".format(str(msg.type))) 43 | 44 | if msg.type == HeadRacketType.DOUBLE_CLICK.value: 45 | observer.stop() 46 | # 执行个舞动 47 | asyncio.create_task(__dance()) 48 | 49 | observer.set_handler(handler) 50 | # 启动 51 | observer.start() 52 | await asyncio.sleep(0) 53 | 54 | 55 | async def __dance(): 56 | await StartBehavior(name="dance_0002").execute() 57 | # 结束event_loop 58 | asyncio.get_running_loop().run_in_executor(None, asyncio.get_running_loop().stop) 59 | 60 | 61 | if __name__ == '__main__': 62 | device: WiFiDevice = asyncio.get_event_loop().run_until_complete(test_get_device_by_name()) 63 | if device: 64 | asyncio.get_event_loop().run_until_complete(test_connect(device)) 65 | asyncio.get_event_loop().run_until_complete(test_start_run_program()) 66 | asyncio.get_event_loop().run_until_complete(test_ObserveHeadRacket()) 67 | # 定义了事件监听对象,必须让event_loop.run_forver() 68 | asyncio.get_event_loop().run_forever() 69 | asyncio.get_event_loop().run_until_complete(shutdown()) 70 | -------------------------------------------------------------------------------- /test/demo_robot_posture.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis.api_observe import ObserveRobotPosture, RobotPosture 4 | from mini.apis.api_sound import StartPlayTTS 5 | from mini.dns.dns_browser import WiFiDevice 6 | from mini.pb2.codemao_observefallclimb_pb2 import ObserveFallClimbResponse 7 | from test.test_connect import test_connect, shutdown 8 | from test.test_connect import test_get_device_by_name, test_start_run_program 9 | 10 | 11 | # 测试,姿态检测 12 | async def test_ObserveRobotPosture(): 13 | """监听机器人姿态demo 14 | 15 | 监听机器人姿态变化事件，机器上报当前的姿态RobotPosture(当发生姿态发生改变的时候) 16 | 17 | 当机器人侧躺(LYING)或平躺(LYINGDOWN)时，停止监听，并播报"我摔倒了" 18 | 19 | # ObserveFallClimbResponse.status 20 | 21 | # STAND = 1; //站立 22 | 23 | # SPLITS_LEFT = 2; //左弓步 24 | 25 | # SPLITS_RIGHT = 3; //右弓步 26 | 27 | # SITDOWN = 4; //坐下 28 | 29 | # SQUATDOWN = 5; //蹲下 30 | 31 | # KNEELING = 6; //跪下 32 | 33 | # LYING = 7; //侧躺 34 | 35 | # LYINGDOWN = 8; //平躺 36 | 37 | # SPLITS_LEFT_1 = 9; //左劈叉 38 | 39 | # SPLITS_RIGHT_2 = 10;//右劈叉 40 | 41 | # BEND = 11;//弯腰 42 | 43 | """ 44 | # 创建监听对象 45 | observer: ObserveRobotPosture = ObserveRobotPosture() 46 | 47 | def handler(msg: ObserveFallClimbResponse): 48 | print("{0}".format(msg)) 49 | if msg.status == RobotPosture.LYING.value or msg.status == RobotPosture.LYING_DOWN.value: 50 | observer.stop() 51 | asyncio.create_task(__tts()) 52 | 53 | observer.set_handler(handler) 54 | # start 55 | observer.start() 56 | await asyncio.sleep(0) 57 | 58 | 59 | async def __tts(): 60 | await StartPlayTTS(text="我摔倒了").execute() 61 | asyncio.get_running_loop().run_in_executor(None, asyncio.get_running_loop().stop) 62 | 63 | 64 | if __name__ == '__main__': 65 | device: WiFiDevice = asyncio.get_event_loop().run_until_complete(test_get_device_by_name()) 66 | if device: 67 | asyncio.get_event_loop().run_until_complete(test_connect(device)) 68 | asyncio.get_event_loop().run_until_complete(test_start_run_program()) 69 | asyncio.get_event_loop().run_until_complete(test_ObserveRobotPosture()) 70 | # 定义了事件监听对象,必须让event_loop.run_forver() 71 | asyncio.get_event_loop().run_forever() 72 | asyncio.get_event_loop().run_until_complete(shutdown()) 73 | -------------------------------------------------------------------------------- /test/test_content.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini import mini_sdk as MiniSdk 4 | from mini.apis.api_content import LanType 5 | from mini.apis.api_content import QueryWiKi, WikiResponse 6 | from mini.apis.api_content import StartTranslate, TranslateResponse 7 | from mini.apis.base_api import MiniApiResultType 8 | from mini.dns.dns_browser import WiFiDevice 9 | from test.test_connect import test_get_device_by_name 10 | 11 | 12 | # 测试, 查询wiki 13 | async def test_query_wiki(): 14 | """查询百科demo 15 | 16 | 查询百科，查询内容"优必选"，并等待结果，机器人播报查询结果 17 | 18 | #WikiResponse.isSuccess : 是否成功 19 | 20 | #WikiResponse.resultCode : 返回码 21 | 22 | """ 23 | # query:查询关键字 24 | block: QueryWiKi = QueryWiKi(query='优必选') 25 | # response : WikiResponse 26 | (resultType, response) = await block.execute() 27 | 28 | print(f'test_query_wiki result: {response}') 29 | 30 | assert resultType == MiniApiResultType.Success, 'test_query_wiki timetout' 31 | assert response is not None and isinstance(response, WikiResponse), 'test_query_wiki result unavailable' 32 | assert response.isSuccess, 'query_wiki failed' 33 | 34 | 35 | # 测试翻译接口 36 | async def test_start_translate(): 37 | """翻译demo 38 | 39 | 使用百度翻译，把"张学友"，从中文翻译成英文，并等待结果，机器人播报翻译结果 40 | 41 | #TranslateResponse.isSuccess : 是否成功 42 | 43 | #TranslateResponse.resultCode : 返回码 44 | 45 | # query: 关键字 46 | 47 | # from_lan: 源语言 48 | 49 | # to_lan: 目标语言 50 | 51 | # platform: BAIDU, GOOGLE, TENCENT 52 | 53 | """ 54 | 55 | block: StartTranslate = StartTranslate(query="张学友", from_lan=LanType.CN, to_lan=LanType.EN) 56 | # response: TranslateResponse 57 | (resultType, response) = await block.execute() 58 | 59 | print(f'test_start_translate result: {response}') 60 | 61 | assert resultType == MiniApiResultType.Success, 'test_start_translate timetout' 62 | assert response is not None and isinstance(response, TranslateResponse), 'test_start_translate result unavailable' 63 | assert response.isSuccess, 'start_translate failed' 64 | 65 | 66 | async def main(): 67 | device: WiFiDevice = await test_get_device_by_name() 68 | if device: 69 | await MiniSdk.connect(device) 70 | await MiniSdk.enter_program() 71 | await test_query_wiki() 72 | await test_start_translate() 73 | await MiniSdk.quit_program() 74 | await MiniSdk.release() 75 | 76 | 77 | if __name__ == '__main__': 78 | asyncio.run(main()) 79 | -------------------------------------------------------------------------------- /test/demo_speech_recognize.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis.api_observe import ObserveSpeechRecognise 4 | from mini.apis.api_sound import StartPlayTTS 5 | from mini.dns.dns_browser import WiFiDevice 6 | from mini.pb2.codemao_speechrecognise_pb2 import SpeechRecogniseResponse 7 | from test.test_connect import test_connect, shutdown 8 | from test.test_connect import test_get_device_by_name, test_start_run_program 9 | 10 | 11 | async def __tts(): 12 | block: StartPlayTTS = StartPlayTTS(text="你好， 我是悟空， 啦里啦，啦里啦") 13 | response = await block.execute() 14 | print(f'tes_play_tts: {response}') 15 | 16 | 17 | # 测试监听语音识别 18 | async def test_speech_recognise(): 19 | """监听语音识别demo 20 | 21 | 监听语音识别事件，机器人上报语音识别后的文字 22 | 23 | 当识别到语音为"悟空"时，播报"你好， 我是悟空， 啦里啦，啦里啦" 24 | 25 | 当识别到语音为"结束"时，停止监听 26 | 27 | # SpeechRecogniseResponse.text 28 | 29 | # SpeechRecogniseResponse.isSuccess 30 | 31 | # SpeechRecogniseResponse.resultCode 32 | 33 | """ 34 | # 语音监听对象 35 | observe: ObserveSpeechRecognise = ObserveSpeechRecognise() 36 | 37 | # 处理器 38 | # SpeechRecogniseResponse.text 39 | # SpeechRecogniseResponse.isSuccess 40 | # SpeechRecogniseResponse.resultCode 41 | def handler(msg: SpeechRecogniseResponse): 42 | print(f'=======handle speech recognise:{msg}') 43 | print("{0}".format(str(msg.text))) 44 | 45 | # if str(msg.text)[-1].isalpha() is False: 46 | # if str(msg.text)[:-1].lower() == "Hello": 47 | # asyncio.create_task(__tts()) 48 | 49 | if str(msg.text).lower() == "悟空": 50 | # 监听到"悟空", tts打个招呼 51 | asyncio.create_task(__tts()) 52 | 53 | elif str(msg.text).lower() == "结束": 54 | # 监听到结束, 停止监听 55 | observe.stop() 56 | # 结束event_loop 57 | asyncio.get_running_loop().run_in_executor(None, asyncio.get_running_loop().stop) 58 | 59 | observe.set_handler(handler) 60 | # 启动 61 | observe.start() 62 | await asyncio.sleep(0) 63 | 64 | 65 | if __name__ == '__main__': 66 | device: WiFiDevice = asyncio.get_event_loop().run_until_complete(test_get_device_by_name()) 67 | if device: 68 | asyncio.get_event_loop().run_until_complete(test_connect(device)) 69 | asyncio.get_event_loop().run_until_complete(test_start_run_program()) 70 | asyncio.get_event_loop().run_until_complete(test_speech_recognise()) 71 | # 定义了事件监听对象,必须让event_loop.run_forver() 72 | asyncio.get_event_loop().run_forever() 73 | asyncio.get_event_loop().run_until_complete(shutdown()) 74 | -------------------------------------------------------------------------------- /test/test_action.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini import mini_sdk as MiniSdk 4 | from mini.apis.api_action import GetActionList, GetActionListResponse, RobotActionType 5 | from mini.apis.api_action import MoveRobot, MoveRobotDirection, MoveRobotResponse 6 | from mini.apis.api_action import PlayAction, PlayActionResponse 7 | from mini.apis.base_api import MiniApiResultType 8 | from mini.dns.dns_browser import WiFiDevice 9 | from test.test_connect import test_get_device_by_name 10 | 11 | 12 | # 测试, 执行一个动作文件 13 | async def test_play_action(): 14 | """执行一个动作demo 15 | 16 | 控制机器人执行一个指定名称的本地(内置/自定义)动作，并等待执行结果回复 17 | 18 | 动作名称可用GetActionList获取 19 | 20 | #PlayActionResponse.isSuccess : 是否成功 21 | 22 | #PlayActionResponse.resultCode : 返回码 23 | 24 | """ 25 | # action_name: 动作文件名, 可以通过GetActionList获取机器人支持的动作 26 | block: PlayAction = PlayAction(action_name='018') 27 | # response: PlayActionResponse 28 | (resultType, response) = await block.execute() 29 | 30 | print(f'test_play_action result:{response}') 31 | 32 | assert resultType == MiniApiResultType.Success, 'test_play_action timetout' 33 | assert response is not None and isinstance(response, PlayActionResponse), 'test_play_action result unavailable' 34 | assert response.isSuccess, 'play_action failed' 35 | 36 | 37 | # 测试, 控制机器人,向前/后/左/右 移动 38 | async def test_move_robot(): 39 | """控制机器人移动demo 40 | 41 | 控制机器人往左(LEFTWARD)移动10步，并等待执行结果 42 | 43 | #MoveRobotResponse.isSuccess : 是否成功　 44 | 45 | #MoveRobotResponse.code : 返回码 46 | 47 | """ 48 | # step: 移动几步 49 | # direction: 方向,枚举类型 50 | block: MoveRobot = MoveRobot(step=10, direction=MoveRobotDirection.LEFTWARD) 51 | # response : MoveRobotResponse 52 | (resultType, response) = await block.execute() 53 | 54 | print(f'test_move_robot result:{response}') 55 | 56 | assert resultType == MiniApiResultType.Success, 'test_move_robot timetout' 57 | assert response is not None and isinstance(response, MoveRobotResponse), 'test_move_robot result unavailable' 58 | assert response.isSuccess, 'move_robot failed' 59 | 60 | 61 | # 测试, 获取支持的动作文件列表 62 | async def test_get_action_list(): 63 | """获取动作列表demo 64 | 65 | 获取机器人内置的动作列表，等待回复结果 66 | 67 | """ 68 | # action_type: INNER 是指机器人内置的不可修改的动作文件, CUSTOM 是放置在sdcard/customize/action目录下可被开发者修改的动作 69 | block: GetActionList = GetActionList(action_type=RobotActionType.INNER) 70 | # response:GetActionListResponse 71 | (resultType, response) = await block.execute() 72 | 73 | print(f'test_get_action_list result:{response}') 74 | 75 | assert resultType == MiniApiResultType.Success, 'test_get_action_list timetout' 76 | assert response is not None and isinstance(response, 77 | GetActionListResponse), 'test_get_action_list result unavailable' 78 | assert response.isSuccess, 'get_action_list failed' 79 | 80 | 81 | async def main(): 82 | device: WiFiDevice = await test_get_device_by_name() 83 | if device: 84 | await MiniSdk.connect(device) 85 | await MiniSdk.enter_program() 86 | await test_play_action() 87 | await test_move_robot() 88 | await test_get_action_list() 89 | await MiniSdk.quit_program() 90 | await MiniSdk.release() 91 | 92 | 93 | if __name__ == '__main__': 94 | asyncio.run(main()) 95 | -------------------------------------------------------------------------------- /test/test_pkg_tool_upload_script.py: -------------------------------------------------------------------------------- 1 | import mini 2 | import mini.pkg_tool as pt 3 | 4 | device = "0717" 5 | 6 | py_script_tts = """import asyncio 7 | import mini 8 | from mini.apis import errors 9 | from mini.apis.api_sound import StartPlayTTS, ControlTTSResponse 10 | from mini.apis.base_api import MiniApiResultType 11 | 12 | 13 | # 测试text合成声音 14 | async def test_play_tts(): 15 | wifiDevice = mini.WiFiDevice(port=8800) 16 | sdk_connect = await mini.mini_sdk.connect(wifiDevice) 17 | print('connect device {0} {1}'.format(wifiDevice, sdk_connect)) 18 | if not sdk_connect: 19 | print("connect failed.......................") 20 | return 21 | await mini.mini_sdk.enter_program() 22 | # text:要合成的文本 23 | block: StartPlayTTS = StartPlayTTS(text="两间公司合并后，新公司将以Cenovus名称继续营运，总部维持于加拿大艾伯塔省卡尔加里。交易已获赫斯基能源公司与Cenovus公司双方董事局一致通过，预期将于明年第一季度完成交易。根据安排协议条款，赫斯基能源股东将会收取0.7845股Cenovus普通股，以及可认购0.0651股Cenovus普通股的认股权证，交换所拥有的每股赫斯基能源普通股。预期交易完成后及行使任何认股权证前，Cenovus股东将拥有合并公司约60.775%股权，赫斯基能源股东则占约39.225%股权。") 24 | # 返回元组, response是个ControlTTSResponse 25 | (resultType, response) = await block.execute() 26 | 27 | print(f'test_play_tts result: {response}') 28 | # StartPlayTTS block的response包含resultCode和isSuccess 29 | # 如果resultCode !=0 可以通过errors.get_speech_error_str(response.resultCode)) 查询错误描述信息 30 | print('resultCode = {0}, error = {1}'.format(response.resultCode, errors.get_speech_error_str(response.resultCode))) 31 | 32 | assert resultType == MiniApiResultType.Success, 'test_play_tts timetout' 33 | assert response is not None and isinstance(response, ControlTTSResponse), 'test_play_tts result unavailable' 34 | assert response.isSuccess, 'test_play_tts failed' 35 | 36 | await mini.mini_sdk.quit_program() 37 | 38 | 39 | async def main(): 40 | await test_play_tts() 41 | 42 | 43 | if __name__ == '__main__': 44 | asyncio.run(main())""" 45 | 46 | py_script_dance = """import asyncio 47 | 48 | import mini 49 | from mini.apis import errors 50 | from mini.apis.api_behavior import StartBehavior 51 | from mini.apis.base_api import MiniApiResultType 52 | from mini.pb2.codemao_controlbehavior_pb2 import ControlBehaviorResponse 53 | 54 | 55 | # 测试text合成声音 56 | async def test_control_behavior(): 57 | wifiDevice = mini.WiFiDevice(port=8800) 58 | sdk_connect = await mini.mini_sdk.connect(wifiDevice) 59 | print('connect device {0} {1}'.format(wifiDevice, sdk_connect)) 60 | if not sdk_connect: 61 | print("connect failed.......................") 62 | return 63 | await mini.mini_sdk.enter_program() 64 | # text:要合成的文本 65 | block: StartBehavior = StartBehavior(name="012") 66 | # 返回元组, response是个ControlTTSResponse 67 | (resultType, response) = await block.execute() 68 | 69 | print(f'test_control_behavior result: {response}') 70 | # StartPlayTTS block的response包含resultCode和isSuccess 71 | # 如果resultCode !=0 可以通过errors.get_speech_error_str(response.resultCode)) 查询错误描述信息 72 | print('resultCode = {0}, error = {1}'.format(response.resultCode, errors.get_express_error_str(response.resultCode))) 73 | 74 | assert resultType == MiniApiResultType.Success, 'test_control_behavior timetout' 75 | assert response is not None and isinstance(response, 76 | ControlBehaviorResponse), 'test_control_behavior result unavailable' 77 | assert response.isSuccess, 'control_behavior failed' 78 | 79 | await mini.mini_sdk.quit_program() 80 | 81 | 82 | async def main(): 83 | await test_control_behavior() 84 | 85 | 86 | if __name__ == '__main__': 87 | asyncio.run(main()) 88 | """ 89 | 90 | fileName = "DanceTest.py" 91 | 92 | 93 | def test_upload_script(): 94 | # 上传脚本到机器人 95 | pt.upload_script(1, device, fileName, bytes(py_script_tts, encoding="utf-8")) 96 | 97 | 98 | def test_check_upload_script(): 99 | # 检查脚本是否已上传到机器人 100 | pt.upload_script(2, device, fileName) 101 | 102 | 103 | def test_run_upload_script(): 104 | # 执行已上传的脚本 105 | pt.upload_script(3, device, fileName) 106 | 107 | 108 | def test_stop_upload_script(): 109 | # 执行已上传的脚本 110 | pt.upload_script(4, device) 111 | 112 | 113 | def test_list_upload_script(): 114 | # 获取已上传的脚本列表 115 | pt.upload_script(5, device) 116 | 117 | 118 | async def release(): 119 | await mini.mini_sdk.release() 120 | 121 | if __name__ == '__main__': 122 | # test_upload_script() 123 | test_check_upload_script() 124 | # test_run_upload_script() 125 | # test_stop_upload_script() 126 | # test_list_upload_script() 127 | -------------------------------------------------------------------------------- /test/test_expression.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis import errors 4 | from mini.apis.api_behavior import StartBehavior, ControlBehaviorResponse, StopBehavior 5 | from mini.apis.api_expression import ControlMouthLamp, ControlMouthResponse 6 | from mini.apis.api_expression import PlayExpression, PlayExpressionResponse 7 | from mini.apis.api_expression import SetMouthLamp, SetMouthLampResponse, MouthLampColor, MouthLampMode 8 | from mini.apis.base_api import MiniApiResultType 9 | from mini.dns.dns_browser import WiFiDevice 10 | from test.test_connect import test_connect, shutdown, test_start_run_program 11 | from test.test_connect import test_get_device_by_name 12 | 13 | 14 | # 测试让眼睛演示个表情 15 | async def test_play_expression(): 16 | """测试播放表情 17 | 18 | 让机器人播放一个名为"codemao1"的内置表情，并等待回复结果 19 | 20 | #PlayExpressionResponse.isSuccess : 是否成功 21 | 22 | #PlayExpressionResponse.resultCode : 返回码 23 | 24 | """ 25 | block: PlayExpression = PlayExpression(express_name="codemao1") 26 | # response: PlayExpressionResponse 27 | (resultType, response) = await block.execute() 28 | 29 | print(f'test_play_expression result: {response}') 30 | 31 | assert resultType == MiniApiResultType.Success, 'test_play_expression timetout' 32 | assert response is not None and isinstance(response, 33 | PlayExpressionResponse), 'test_play_expression result unavailable' 34 | assert response.isSuccess, 'play_expression failed' 35 | 36 | 37 | # 测试, 让机器人跳舞/停止跳舞 38 | async def test_control_behavior(): 39 | """测试控制表现力 40 | 41 | 让机器人开始跳一个名为"dance_0004"的舞蹈，并等待回复结果 42 | 43 | """ 44 | # control_type: START, STOP 45 | block: StartBehavior = StartBehavior(name="dance_0004") 46 | # response ControlBehaviorResponse 47 | (resultType, response) = await block.execute() 48 | 49 | print(f'test_control_behavior result: {response}') 50 | print( 51 | 'resultCode = {0}, error = {1}'.format(response.resultCode, errors.get_express_error_str(response.resultCode))) 52 | 53 | assert resultType == MiniApiResultType.Success, 'test_control_behavior timetout' 54 | assert response is not None and isinstance(response, 55 | ControlBehaviorResponse), 'test_control_behavior result unavailable' 56 | assert response.isSuccess, 'control_behavior failed' 57 | 58 | 59 | async def test_stop_behavior(): 60 | # 开始 61 | block: StartBehavior = StartBehavior(name="dance_0004") 62 | # response ControlBehaviorResponse 63 | asyncio.create_task(await block.execute()) 64 | 65 | # 5秒后停止 66 | await asyncio.sleep(5) 67 | block: StopBehavior = StopBehavior() 68 | (resultType, response) = await block.execute() 69 | print(f'test_stop_behavior result: {response}') 70 | 71 | 72 | # 测试, 设置嘴巴灯颜色为绿色 常亮 73 | async def test_set_mouth_lamp(): 74 | # mode: 嘴巴灯模式，0：普通模式，1：呼吸模式 75 | 76 | # color: 嘴巴灯颜色，1：红色，2：绿色，3：蓝色 77 | 78 | # duration: 持续时间，单位为毫秒，-1表示常亮 79 | 80 | # breath_duration: 闪烁一次时长，单位为毫秒 81 | 82 | """测试设置嘴巴灯 83 | 84 | 设置机器人嘴巴灯正常模式、绿色、常亮3s，并等待回复结果 85 | 86 | 当mode=NORMAL时，duration参数起作用，表示常亮多久时间 87 | 88 | 当mode=BREATH，breath_duration参数起作用，表示多久呼吸一次 89 | 90 | #SetMouthLampResponse.isSuccess : 是否成功 91 | 92 | #SetMouthLampResponse.resultCode : 返回码 93 | 94 | """ 95 | 96 | block: SetMouthLamp = SetMouthLamp(color=MouthLampColor.GREEN, mode=MouthLampMode.NORMAL, 97 | duration=3000, breath_duration=1000) 98 | # response:SetMouthLampResponse 99 | (resultType, response) = await block.execute() 100 | 101 | print(f'test_set_mouth_lamp result: {response}') 102 | 103 | assert resultType == MiniApiResultType.Success, 'test_set_mouth_lamp timetout' 104 | assert response is not None and isinstance(response, SetMouthLampResponse), 'test_set_mouth_lamp result unavailable' 105 | assert response.isSuccess or response.resultCode == 504, 'set_mouth_lamp failed' 106 | 107 | 108 | # 测试,开关嘴巴灯 109 | async def test_control_mouth_lamp(): 110 | """测试控制嘴巴灯 111 | 112 | 让机器人嘴巴灯关闭，并等待结果 113 | 114 | #ControlMouthResponse.isSuccess : 是否成功 115 | 116 | #ControlMouthResponse.resultCode : 返回码 117 | 118 | """ 119 | # is_open: True,False 120 | # response :ControlMouthResponse 121 | (resultType, response) = await ControlMouthLamp(is_open=False).execute() 122 | 123 | print(f'test_control_mouth_lamp result: {response}') 124 | 125 | assert resultType == MiniApiResultType.Success, 'test_control_mouth_lamp timetout' 126 | assert response is not None and isinstance(response, 127 | ControlMouthResponse), 'test_control_mouth_lamp result unavailable' 128 | assert response.isSuccess or response.resultCode == 504, 'control_mouth_lamp failed' 129 | 130 | 131 | async def main(): 132 | device: WiFiDevice = await test_get_device_by_name() 133 | if device: 134 | await test_connect(device) 135 | await test_start_run_program() 136 | await test_play_expression() 137 | await test_set_mouth_lamp() 138 | await test_control_mouth_lamp() 139 | await test_control_behavior() 140 | await shutdown() 141 | 142 | 143 | if __name__ == '__main__': 144 | asyncio.run(main()) 145 | -------------------------------------------------------------------------------- /test/test_event.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | 3 | import asyncio 4 | 5 | from mini.apis.api_observe import ObserveFaceDetect, FaceDetectTaskResponse 6 | from mini.apis.api_observe import ObserveFaceRecognise, FaceRecogniseTaskResponse 7 | from mini.apis.api_observe import ObserveHeadRacket, ObserveHeadRacketResponse 8 | from mini.apis.api_observe import ObserveInfraredDistance, ObserveInfraredDistanceResponse 9 | from mini.apis.api_observe import ObserveRobotPosture, ObserveFallClimbResponse 10 | from mini.apis.api_observe import ObserveSpeechRecognise, SpeechRecogniseResponse 11 | from mini.dns.dns_browser import WiFiDevice 12 | from test.test_connect import test_connect, shutdown 13 | from test.test_connect import test_get_device_by_name, test_start_run_program 14 | 15 | 16 | async def test_speech_recognise(): 17 | """测试监听语音识别 18 | 19 | 监听语音识别事件，校验识别是否成功，识别的结果文本是否有值，把结果存入result数组 20 | 21 | 延时5s，结束函数，校验result中是否有值 22 | 23 | """ 24 | result = [] 25 | 26 | observer: ObserveSpeechRecognise = ObserveSpeechRecognise() 27 | 28 | def handler(msg): 29 | print(f"test_speech_recognise handle msg:{msg.text}") 30 | 31 | assert msg is not None and isinstance(msg, SpeechRecogniseResponse), "test_speech_recognise result not " \ 32 | "available " 33 | assert msg.isSuccess, "test_speech_recognise failed" 34 | 35 | assert len(msg.text), "test_speech_recognise text is nothing" 36 | 37 | result.append(msg.text) 38 | 39 | observer.set_handler(handler) 40 | observer.start() 41 | 42 | await asyncio.sleep(10) 43 | 44 | print('---- stop ObserveSpeechRecognise') 45 | observer.stop() 46 | 47 | await asyncio.sleep(5) 48 | 49 | assert len(result), "test_speech_recognise result nil" 50 | 51 | 52 | async def test_face_detect(): 53 | """测试监听人脸个数 54 | 55 | 监听人脸个数，校验成功结果，校验人脸个数大于0(需要有人脸在机器人面前)，把人脸个数结果存入result数组 56 | 57 | 延时5s，结束函数，校验result数组是否有值 58 | 59 | """ 60 | result = [] 61 | 62 | observer: ObserveFaceDetect = ObserveFaceDetect() 63 | 64 | def handler(msg): 65 | print(f"test_face_detect handle msg:{msg}") 66 | 67 | assert msg is not None and isinstance(msg, FaceDetectTaskResponse), "test_face_detect result not " \ 68 | "available " 69 | assert msg.isSuccess, "test_face_detect failed" 70 | 71 | assert msg.count, "test_face_detect count is 0" 72 | 73 | result.append(msg.count) 74 | 75 | observer.set_handler(handler) 76 | observer.start() 77 | 78 | await asyncio.sleep(10) 79 | 80 | print('---- stop ObserveFaceDetect') 81 | observer.stop() 82 | 83 | await asyncio.sleep(5) 84 | 85 | assert len(result), "test_face_detect result nil" 86 | 87 | 88 | async def test_face_recognise(): 89 | """测试监听人脸识别 90 | 91 | 监听人脸识别事件，校验成功结果，校验识别到的人脸信息是否为空(需有人脸在机器人面前)，并把人脸信息存入result数组 92 | 93 | 10s后结束监听 94 | 95 | 延时5s，结束函数，校验result数组是否有值 96 | 97 | """ 98 | result = [] 99 | 100 | observer: ObserveFaceRecognise = ObserveFaceRecognise() 101 | 102 | def handler(msg): 103 | print(f"test_face_recognise handle msg:{msg}") 104 | 105 | assert msg is not None and isinstance(msg, FaceRecogniseTaskResponse), "test_face_recognise result not " \ 106 | "available " 107 | assert msg.isSuccess, "test_face_recognise failed" 108 | 109 | assert msg.faceInfos is not None, "test_face_recognise faceInfos is nil" 110 | 111 | result.append(msg.faceInfos) 112 | 113 | observer.set_handler(handler) 114 | observer.start() 115 | 116 | await asyncio.sleep(10) 117 | 118 | print('---- stop ObserveFaceRecognise') 119 | observer.stop() 120 | 121 | await asyncio.sleep(5) 122 | 123 | assert len(result), "ObserveFaceRecognise result nil" 124 | 125 | 126 | async def test_infrared_distance(): 127 | """测试监听红外距离 128 | 129 | 监听红外距离事件，校验结果distance是否有效(distance>0)，并存入result数组 130 | 131 | 延时5s，结束函数，校验result数组是否有值 132 | 133 | Returns: 134 | 135 | """ 136 | result = [] 137 | 138 | observer: ObserveInfraredDistance = ObserveInfraredDistance() 139 | 140 | def handler(msg): 141 | print(f"test_infrared_distance handle msg:{msg}") 142 | 143 | assert msg is not None and isinstance(msg, ObserveInfraredDistanceResponse), "test_infrared_distance result " \ 144 | "not " \ 145 | "available " 146 | # assert msg.isSuccess, "test_infrared_distance failed" 147 | 148 | assert msg.distance is not None and msg.distance > 0, "test_infrared_distance distance unavailable" 149 | 150 | result.append(msg.distance) 151 | 152 | observer.set_handler(handler) 153 | observer.start() 154 | 155 | await asyncio.sleep(10) 156 | 157 | print('---- stop ObserveInfraredDistance') 158 | observer.stop() 159 | 160 | await asyncio.sleep(5) 161 | 162 | assert len(result), "ObserveInfraredDistance result nil" 163 | 164 | 165 | async def test_robot_posture(): 166 | """测试监听机器人姿态变化 167 | 168 | 监听机器人姿态变化(需手动改变机器人姿态)，校验结果status是否有效(status>0)，并存入result数组 169 | 170 | 延时5s，结束函数，并校验result数组是否有值 171 | 172 | Returns: 173 | 174 | """ 175 | result = [] 176 | 177 | observer: ObserveRobotPosture = ObserveRobotPosture() 178 | 179 | def handler(msg): 180 | print(f"test_robot_posture handle msg:{msg}") 181 | 182 | assert msg is not None and isinstance(msg, ObserveFallClimbResponse), "test_robot_posture result " \ 183 | "not " \ 184 | "available " 185 | # assert msg.isSuccess, "test_infrared_distance failed" 186 | 187 | assert msg.status is not None and msg.status > 0, "test_robot_posture status unavailable" 188 | 189 | result.append(msg.status) 190 | 191 | observer.set_handler(handler) 192 | observer.start() 193 | 194 | await asyncio.sleep(10) 195 | 196 | print('---- stop ObserveRobotPosture') 197 | observer.stop() 198 | 199 | await asyncio.sleep(5) 200 | 201 | assert len(result), "ObserveRobotPosture result nil" 202 | 203 | 204 | async def test_head_racket(): 205 | """测试监听拍头事件 206 | 207 | 监听机器人拍头事件(需手动拍打机器人头部)，校验结果type是否有效(type>0)，并存入result数组 208 | 209 | 延时5s，结束函数，并校验result数组是否有值 210 | 211 | Returns: 212 | 213 | """ 214 | result = [] 215 | 216 | observer: ObserveHeadRacket = ObserveHeadRacket() 217 | 218 | def handler(msg): 219 | print(f"test_head_racket handle msg:{msg}") 220 | 221 | assert msg is not None and isinstance(msg, ObserveHeadRacketResponse), "test_head_racket result " \ 222 | "not " \ 223 | "available " 224 | # assert msg.isSuccess, "test_infrared_distance failed" 225 | 226 | assert msg.type is not None and msg.type > 0, "test_head_racket type unavailable" 227 | 228 | result.append(msg.type) 229 | 230 | observer.set_handler(handler) 231 | observer.start() 232 | 233 | await asyncio.sleep(10) 234 | 235 | print('---- stop ObserveHeadRacket') 236 | observer.stop() 237 | 238 | await asyncio.sleep(5) 239 | 240 | assert len(result), "ObserveHeadRacket result nil" 241 | 242 | 243 | async def main(): 244 | device: WiFiDevice = await test_get_device_by_name() 245 | if device: 246 | await test_connect(device) 247 | await test_start_run_program() 248 | 249 | await test_speech_recognise() 250 | await test_face_detect() 251 | await test_face_recognise() 252 | await test_infrared_distance() 253 | await test_robot_posture() 254 | await test_head_racket() 255 | 256 | await shutdown() 257 | 258 | 259 | if __name__ == '__main__': 260 | asyncio.run(main()) 261 | -------------------------------------------------------------------------------- /test/test_sound.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis import errors 4 | from mini.apis.api_sound import ChangeRobotVolume, ChangeRobotVolumeResponse 5 | from mini.apis.api_sound import FetchAudioList, GetAudioListResponse, AudioSearchType 6 | from mini.apis.api_sound import PlayAudio, PlayAudioResponse, AudioStorageType 7 | # from mini.apis.api_sound import PlayOnlineMusic, MusicResponse 8 | from mini.apis.api_sound import StartPlayTTS, StopPlayTTS, ControlTTSResponse 9 | from mini.apis.api_sound import StopAllAudio, StopAudioResponse 10 | from mini.apis.base_api import MiniApiResultType 11 | from mini.dns.dns_browser import WiFiDevice 12 | from test.test_connect import test_connect, shutdown 13 | from test.test_connect import test_get_device_by_name, test_start_run_program 14 | 15 | 16 | # 测试text合成声音 17 | async def test_play_tts(): 18 | """测试播放tts 19 | 20 | 使机器人开始播放一段tts，内容为"你好， 我是悟空， 啦啦啦"，并等待结果 21 | 22 | #ControlTTSResponse.isSuccess : 是否成功 23 | 24 | #ControlTTSResponse.resultCode : 返回码 25 | 26 | """ 27 | # is_serial:串行执行 28 | # text:要合成的文本 29 | block: StartPlayTTS = StartPlayTTS(text="你好， 我是悟空， 啦啦啦") 30 | # 返回元组, response是个ControlTTSResponse 31 | (resultType, response) = await block.execute() 32 | 33 | print(f'test_play_tts result: {response}') 34 | # StartPlayTTS block的response包含resultCode和isSuccess 35 | # 如果resultCode !=0 可以通过errors.get_speech_error_str(response.resultCode)) 查询错误描述信息 36 | print('resultCode = {0}, error = {1}'.format(response.resultCode, errors.get_speech_error_str(response.resultCode))) 37 | 38 | assert resultType == MiniApiResultType.Success, 'test_play_tts timetout' 39 | assert response is not None and isinstance(response, ControlTTSResponse), 'test_play_tts result unavailable' 40 | assert response.isSuccess, 'test_play_tts failed' 41 | 42 | 43 | async def test_stop_play_tts(): 44 | """测试停止播放tts 45 | 46 | 使机器人开始播放一段长文本tts，内容为"你好， 我是悟空， 啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦"，不等待结果 47 | 2s后，使机器人停止播放tts 48 | 49 | #ControlTTSResponse.isSuccess : 是否成功 50 | 51 | #ControlTTSResponse.resultCode : 返回码 52 | 53 | """ 54 | # is_serial:串行执行 55 | # text:要合成的文本 56 | block: StartPlayTTS = StartPlayTTS(is_serial=False, text="你好， 我是悟空， 啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦啦") 57 | # 返回bool 表示是否发送成功 58 | await block.execute() 59 | 60 | await asyncio.sleep(2) 61 | 62 | (resultType, response) = await StopPlayTTS().execute() 63 | 64 | print(f'test_stop_play_tts result: {response}') 65 | # StopPlayTTS block的response包含resultCode和isSuccess 66 | # 如果resultCode !=0 可以通过errors.get_speech_error_str(response.resultCode)) 查询错误描述信息 67 | print('resultCode = {0}, error = {1}'.format(response.resultCode, errors.get_speech_error_str(response.resultCode))) 68 | 69 | assert resultType == MiniApiResultType.Success, 'test_stop_play_tts timetout' 70 | assert response is not None and isinstance(response, ControlTTSResponse), 'test_stop_play_tts result unavailable' 71 | assert response.isSuccess, 'test_stop_play_tts failed' 72 | 73 | 74 | # 测试播放音效(在线) 75 | async def test_play_online_audio(): 76 | """测试播放在线音效 77 | 78 | 使机器人播放一段在线音效，例如"http://hao.haolingsheng.com/ring/000/995/52513bb6a4546b8822c89034afb8bacb.mp3" 79 | 80 | 支持格式有mp3,amr,wav 等 81 | 82 | 并等待结果 83 | 84 | #PlayAudioResponse.isSuccess : 是否成功 85 | 86 | #PlayAudioResponse.resultCode : 返回码 87 | 88 | """ 89 | # 播放音效, url表示要播放的音效列表 90 | block: PlayAudio = PlayAudio( 91 | url="http://hao.haolingsheng.com/ring/000/995/52513bb6a4546b8822c89034afb8bacb.mp3", 92 | storage_type=AudioStorageType.NET_PUBLIC) 93 | # response是个PlayAudioResponse 94 | (resultType, response) = await block.execute() 95 | 96 | print(f'test_play_online_audio result: {response}') 97 | print('resultCode = {0}, error = {1}'.format(response.resultCode, errors.get_speech_error_str(response.resultCode))) 98 | 99 | assert resultType == MiniApiResultType.Success, 'test_play_online_audio timetout' 100 | assert response is not None and isinstance(response, PlayAudioResponse), 'test_play_online_audio result unavailable' 101 | assert response.isSuccess, 'test_play_online_audio failed' 102 | 103 | 104 | async def test_play_local_audio(): 105 | """测试播放本地音效 106 | 107 | 使机器人播放一段本地内置音效，音效名称为"read_016"，并等待结果 108 | 109 | #PlayAudioResponse.isSuccess : 是否成功 110 | 111 | #PlayAudioResponse.resultCode : 返回码 112 | 113 | """ 114 | 115 | block: PlayAudio = PlayAudio( 116 | url="read_016", 117 | storage_type=AudioStorageType.PRESET_LOCAL) 118 | # response是个PlayAudioResponse 119 | (resultType, response) = await block.execute() 120 | 121 | print(f'test_play_local_audio result: {response}') 122 | print('resultCode = {0}, error = {1}'.format(response.resultCode, errors.get_speech_error_str(response.resultCode))) 123 | 124 | assert resultType == MiniApiResultType.Success, 'test_play_local_audio timetout' 125 | assert response is not None and isinstance(response, PlayAudioResponse), 'test_play_local_audio result unavailable' 126 | assert response.isSuccess, 'test_play_local_audio failed' 127 | 128 | 129 | # 测试获取机器人的音效资源 130 | async def test_get_audio_list(): 131 | """测试获取音效列表 132 | 133 | 获取机器人内置的音效列表，并等待结果 134 | 135 | #GetAudioListResponse.audio ([Audio]) : 音效列表 136 | 137 | #Audio.name : 音效名 138 | 139 | #Audio.suffix : 音效后缀 140 | 141 | #GetAudioListResponse.isSuccess : 是否成功 142 | 143 | #GetAudioListResponse.resultCode : 返回码 144 | 145 | """ 146 | # search_type: AudioSearchType.INNER 是指机器人内置的不可修改的音效, AudioSearchType.CUSTOM 是放置在sdcard/customize/music目录下可别开发者修改的音效 147 | block: FetchAudioList = FetchAudioList(search_type=AudioSearchType.INNER) 148 | # response是个GetAudioListResponse 149 | (resultType, response) = await block.execute() 150 | 151 | print(f'test_get_audio_list result: {response}') 152 | 153 | assert resultType == MiniApiResultType.Success, 'test_get_audio_list timetout' 154 | assert response is not None and isinstance(response, GetAudioListResponse), 'test_play_audio result unavailable' 155 | assert response.isSuccess, 'test_get_audio_list failed' 156 | 157 | 158 | # 测试停止正在播放的tts 159 | async def test_stop_audio_tts(): 160 | """测试停止所有正在播放的音频 161 | 162 | 先播放一段tts，3s后，停止所有所有音效，并等待结果 163 | 164 | #StopAudioResponse.isSuccess : 是否成功　 165 | 166 | #StopAudioResponse.resultCode : 返回码 167 | 168 | """ 169 | # 设置is_serial=False, 表示只需将指令发送给机器人,await不需要等机器人执行完结果再返回 170 | block: StartPlayTTS = StartPlayTTS(is_serial=False, text="你让我说，让我说，不要打断我，不要打断我，不要打断我") 171 | response = await block.execute() 172 | print(f'test_stop_audio.play_tts: {response}') 173 | await asyncio.sleep(3) 174 | 175 | # 停止所有声音 176 | block: StopAllAudio = StopAllAudio() 177 | (resultType, response) = await block.execute() 178 | 179 | print(f'test_stop_audio:{response}') 180 | 181 | block: StartPlayTTS = StartPlayTTS(text="第二次, 你让我说，让我说，不要打断我，不要打断我，不要打断我") 182 | asyncio.create_task(block.execute()) 183 | print(f'test_stop_audio.play_tts: {response}') 184 | await asyncio.sleep(3) 185 | 186 | assert resultType == MiniApiResultType.Success, 'test_stop_audio timetout' 187 | assert response is not None and isinstance(response, StopAudioResponse), 'test_stop_audio result unavailable' 188 | assert response.isSuccess, 'test_stop_audio failed' 189 | 190 | 191 | # 测试, 改变机器人的音量 192 | async def test_change_robot_volume(): 193 | """调整机器人音量demo 194 | 195 | 设置机器人音量为0.5，等待回复结果 196 | 197 | #ChangeRobotVolumeResponse.isSuccess : 是否成功 198 | 199 | #ChangeRobotVolumeResponse.resultCode : 返回码 200 | 201 | """ 202 | # volume: 0~1.0 203 | block: ChangeRobotVolume = ChangeRobotVolume(volume=0.5) 204 | # response:ChangeRobotVolumeResponse 205 | (resultType, response) = await block.execute() 206 | 207 | print(f'test_change_robot_volume result:{response}') 208 | 209 | assert resultType == MiniApiResultType.Success, 'test_change_robot_volume timetout' 210 | assert response is not None and isinstance(response, 211 | ChangeRobotVolumeResponse), 'test_change_robot_volume result unavailable' 212 | assert response.isSuccess, 'get_action_list failed' 213 | 214 | 215 | async def main(): 216 | device: WiFiDevice = await test_get_device_by_name() 217 | if device: 218 | await test_connect(device) 219 | await test_start_run_program() 220 | await test_play_tts() 221 | await test_stop_play_tts() 222 | await test_get_audio_list() 223 | await test_play_local_audio() 224 | await test_play_online_audio() 225 | await test_stop_audio_tts() 226 | await test_change_robot_volume() 227 | await shutdown() 228 | 229 | 230 | if __name__ == '__main__': 231 | asyncio.run(main()) 232 | -------------------------------------------------------------------------------- /test/test_sence.py: -------------------------------------------------------------------------------- 1 | import asyncio 2 | 3 | from mini.apis import errors 4 | from mini.apis.api_sence import FaceAnalysis, FaceAnalyzeResponse 5 | from mini.apis.api_sence import FaceDetect, FaceDetectResponse 6 | from mini.apis.api_sence import FaceRecognise, FaceRecogniseResponse 7 | from mini.apis.api_sence import GetInfraredDistance, GetInfraredDistanceResponse 8 | from mini.apis.api_sence import GetRegisterFaces, GetRegisterFacesResponse 9 | from mini.apis.api_sence import ObjectRecognise, RecogniseObjectResponse, ObjectRecogniseType 10 | from mini.apis.api_sence import TakePicture, TakePictureResponse, TakePictureType 11 | from mini.apis.base_api import MiniApiResultType 12 | from mini.dns.dns_browser import WiFiDevice 13 | from test.test_connect import test_connect, shutdown, test_start_run_program 14 | from test.test_connect import test_get_device_by_name 15 | 16 | 17 | # 测试人脸侦测 18 | async def test_face_detect(): 19 | """测试人脸个数侦测 20 | 21 | 侦测人脸个数，10s超时，并等待回复结果 22 | 23 | #FaceDetectResponse.count : 人脸个数 24 | 25 | #FaceDetectResponse.isSuccess : 是否成功 26 | 27 | #FaceDetectResponse.resultCode : 返回码 28 | 29 | """ 30 | # timeout: 指定侦测时长 31 | block: FaceDetect = FaceDetect(timeout=10) 32 | # response: FaceDetectResponse 33 | (resultType, response) = await block.execute() 34 | 35 | print(f'test_face_detect result: {response}') 36 | 37 | assert resultType == MiniApiResultType.Success, 'test_face_detect timetout' 38 | assert response is not None and isinstance(response, FaceDetectResponse), 'test_face_detect result unavailable' 39 | assert response.isSuccess, 'face_detect failed' 40 | 41 | 42 | # 测试人脸分析(性别) 43 | async def test_face_analysis(): 44 | """测试人脸分析（性别） 45 | 46 | 侦测人脸信息(性别、年龄)，超时时间10s，并等待回复结果 47 | 48 | 当多人存在摄像头前时，返回占画面比例最大的那个人脸信息 49 | 50 | 返回值：示例 {"age": 24, "gender": 99, "height": 238, "width": 238} 51 | 52 | age: 年龄 53 | 54 | gender：[1, 100], 小于50为女性，大于50为男性 55 | 56 | height：人脸在摄像头画面中的高度 57 | 58 | width：人脸在摄像头画面中的宽度 59 | 60 | """ 61 | block: FaceAnalysis = FaceAnalysis(timeout=10) 62 | # response: FaceAnalyzeResponse 63 | (resultType, response) = await block.execute() 64 | 65 | print(f'test_face_analysis result: {response}') 66 | print('code = {0}, error={1}'.format(response.resultCode, errors.get_vision_error_str(response.resultCode))) 67 | 68 | assert resultType == MiniApiResultType.Success, 'test_face_analysis timetout' 69 | assert response is not None and isinstance(response, FaceAnalyzeResponse), 'test_face_analysis result unavailable' 70 | assert response.isSuccess, 'face_analysis failed' 71 | 72 | 73 | # 测试物体识别：识别花，10s超时 74 | async def test_object_recognise_flower(): 75 | """测试物体(花)识别 76 | 77 | 让机器人识别花(需手动把花或花的照片放到机器人面前)，超时10s，并等待结果 78 | 79 | #RecogniseObjectResponse.objects : 物体名数组[str] 80 | 81 | #RecogniseObjectResponse.isSuccess : 是否成功 82 | 83 | #RecogniseObjectResponse.resultCode : 返回码 84 | 85 | """ 86 | # object_type: 支持FLOWER, FRUIT, GESTURE 三类物体 87 | block: ObjectRecognise = ObjectRecognise(object_type=ObjectRecogniseType.FLOWER, timeout=10) 88 | # response : RecogniseObjectResponse 89 | (resultType, response) = await block.execute() 90 | 91 | print(f'test_object_recognise_flower result: {response}') 92 | 93 | assert resultType == MiniApiResultType.Success, 'test_object_recognise_flower timetout' 94 | assert response is not None and isinstance(response, 95 | RecogniseObjectResponse), 'test_object_recognise_flower result unavailable' 96 | assert response.isSuccess, 'test_object_recognise_flower failed' 97 | 98 | 99 | # 测试物体识别：识别水果，10s超时 100 | async def test_object_recognise_fruit(): 101 | """测试物体(水果)识别 102 | 103 | 让机器人识别花(需手动把水果或水果的照片放到机器人面前)，超时10s，并等待结果 104 | 105 | #RecogniseObjectResponse.objects : 物体名数组[str] 106 | 107 | #RecogniseObjectResponse.isSuccess : 是否成功 108 | 109 | #RecogniseObjectResponse.resultCode : 返回码 110 | 111 | """ 112 | # object_type: 支持FLOWER, FRUIT, GESTURE 三类物体 113 | block: ObjectRecognise = ObjectRecognise(object_type=ObjectRecogniseType.FRUIT, timeout=10) 114 | # response : RecogniseObjectResponse 115 | (resultType, response) = await block.execute() 116 | 117 | print(f'test_object_recognise_fruit result: {response}') 118 | 119 | assert resultType == MiniApiResultType.Success, 'test_object_recognise_fruit timetout' 120 | assert response is not None and isinstance(response, 121 | RecogniseObjectResponse), 'test_object_recognise_fruit result unavailable' 122 | assert response.isSuccess, 'test_object_recognise_fruit failed' 123 | 124 | 125 | # 测试物体识别：识别手势，10s超时 126 | async def test_object_recognise_gesture(): 127 | """测试物体(手势)识别 128 | 129 | 让机器人识别花(需手动在机器人面前作出手势)，超时10s，并等待结果 130 | 131 | #RecogniseObjectResponse.objects : 物体名数组[str] 132 | 133 | #RecogniseObjectResponse.isSuccess : 是否成功 134 | 135 | #RecogniseObjectResponse.resultCode : 返回码 136 | 137 | """ 138 | # object_type: 支持FLOWER, FRUIT, GESTURE 三类物体 139 | block: ObjectRecognise = ObjectRecognise(object_type=ObjectRecogniseType.GESTURE, timeout=10) 140 | # response : RecogniseObjectResponse 141 | (resultType, response) = await block.execute() 142 | 143 | print(f'test_object_recognise_gesture result: {response}') 144 | 145 | assert resultType == MiniApiResultType.Success, 'test_object_recognise_gesture timetout' 146 | assert response is not None and isinstance(response, 147 | RecogniseObjectResponse), 'test_object_recognise_gesture result unavailable' 148 | assert response.isSuccess, 'test_object_recognise_gesture failed' 149 | 150 | 151 | # 测试拍照 152 | async def test_take_picture(): 153 | """测试拍照 154 | 155 | 让机器人立即拍照，并等待结果 156 | 157 | #TakePictureResponse.isSuccess : 是否成功 158 | 159 | #TakePictureResponse.code : 返回码 160 | 161 | #TakePictureResponse.picPath : 照片在机器人里的存储路径 162 | 163 | """ 164 | # response: TakePictureResponse 165 | # take_picture_type: IMMEDIATELY-立即拍照, FINDFACE-找到人脸再拍照 两种拍照效果 166 | (resultType, response) = await TakePicture(take_picture_type=TakePictureType.IMMEDIATELY).execute() 167 | 168 | print(f'test_take_picture result: {response}') 169 | 170 | assert resultType == MiniApiResultType.Success, 'test_take_picture timetout' 171 | assert response is not None and isinstance(response, TakePictureResponse), 'test_take_picture result unavailable' 172 | assert response.isSuccess, 'test_take_picture failed' 173 | 174 | 175 | # 测试人脸识别 176 | async def test_face_recognise(): 177 | """测试人脸识别 178 | 179 | 让机器人进行人脸识别检测，超时10s，并等待结果 180 | 181 | 182 | #FaceRecogniseResponse.faceInfos : [FaceInfoResponse] 人脸信息数组 183 | 184 | FaceInfoResponse.id : 人脸id 185 | 186 | FaceInfoResponse.name : 姓名，如果是陌生人，则默认name为"stranger" 187 | 188 | FaceInfoResponse.gender : 性别 189 | 190 | FaceInfoResponse.age : 年龄 191 | 192 | #FaceRecogniseResponse.isSuccess : 是否成功 193 | 194 | #FaceRecogniseResponse.resultCode : 返回码 195 | 196 | Returns: 197 | 198 | """ 199 | # response : FaceRecogniseResponse 200 | (resultType, response) = await FaceRecognise(timeout=10).execute() 201 | 202 | print(f'test_face_recognise result: {response}') 203 | 204 | assert resultType == MiniApiResultType.Success, 'test_face_recognise timetout' 205 | assert response is not None and isinstance(response, 206 | FaceRecogniseResponse), 'test_face_recognise result unavailable' 207 | assert response.isSuccess, 'test_face_recognise failed' 208 | 209 | 210 | # 测试获取红外探测距离 211 | async def test_get_infrared_distance(): 212 | """测试红外距离检测 213 | 214 | 获取当前机器人检测到的红外距离，并等待结果 215 | 216 | #GetInfraredDistanceResponse.distance : 红外距离 217 | 218 | """ 219 | # response: GetInfraredDistanceResponse 220 | (resultType, response) = await GetInfraredDistance().execute() 221 | 222 | print(f'test_get_infrared_distance result: {response}') 223 | 224 | assert resultType == MiniApiResultType.Success, 'test_get_infrared_distance timetout' 225 | assert response is not None and isinstance(response, 226 | GetInfraredDistanceResponse), 'test_get_infrared_distance result unavailable' 227 | assert response.distance > 0, 'test_get_infrared_distance failed' 228 | 229 | 230 | # 测试获取目前机器人内注册的人脸个数 231 | async def test_get_register_faces(): 232 | """测试获取已注册的人脸信息 233 | 234 | 获取在机器人中已注册的所有人脸信息，并等待结果 235 | 236 | #GetRegisterFacesResponse.faceInfos : [FaceInfoResponse] 人脸信息数组 237 | 238 | #FaceInfoResponse.id : 人脸id 239 | 240 | #FaceInfoResponse.name : 姓名 241 | 242 | #FaceInfoResponse.gender : 性别 243 | 244 | #FaceInfoResponse.age : 年龄 245 | 246 | #GetRegisterFacesResponse.isSuccess : 是否成功 247 | 248 | #GetRegisterFacesResponse.resultCode : 返回码 249 | 250 | Returns: 251 | 252 | """ 253 | # reponse : GetRegisterFacesResponse 254 | (resultType, response) = await GetRegisterFaces().execute() 255 | 256 | print(f'test_get_register_faces result: {response}') 257 | 258 | assert resultType == MiniApiResultType.Success, 'test_get_register_faces timetout' 259 | assert response is not None and isinstance(response, 260 | GetRegisterFacesResponse), 'test_get_register_faces result unavailable' 261 | assert response.isSuccess, 'test_get_register_faces failed' 262 | 263 | 264 | async def main(): 265 | device: WiFiDevice = await test_get_device_by_name() 266 | if device: 267 | await test_connect(device) 268 | await test_start_run_program() 269 | 270 | await test_face_detect() 271 | await test_face_analysis() 272 | await test_take_picture() 273 | await test_face_recognise() 274 | await test_get_infrared_distance() 275 | await test_get_register_faces() 276 | await test_object_recognise_flower() 277 | await test_object_recognise_fruit() 278 | await test_object_recognise_gesture() 279 | 280 | await shutdown() 281 | 282 | 283 | if __name__ == '__main__': 284 | asyncio.run(main()) 285 | --------------------------------------------------------------------------------