class SmartSpeaker():
def __init__(self):
self.interrupted = False
self.model = "snowboy.pmdl"
signal.signal(signal.SIGINT, self.signal_handler)
self.detector = snowboydecoder.HotwordDetector(self.model,
sensitivity=0.42)
print('Listening... Press Ctrl+C to exit')
self.robot = Robot()
self.music_player = self.robot.get_music_player()
self.player = Player()
def signal_handler(self, signal, frame):
self.interrupted = True
def interrupt_callback(self):
return self.interrupted
def detected_callback(self):
self.music_player.pause()
self.player.play_ding()
def speeched_callback(self, fname):
self.player.play_dong()
self.robot.process(fname)
sleep(1)
self.music_player.cont()
def run(self):
self.detector.start(detected_callback=self.detected_callback,
speeched_callback=self.speeched_callback,
interrupt_check=self.interrupt_callback,
sleep_time=0.03)
class SmartSpeaker():
# 初始化
def __init__(self):
self.interrupted = False
self.model = "嘿小二.pmdl" # 使用的语音模型
signal.signal(signal.SIGINT, self.signal_handler) # 捕获ctrl+c
self.detector = snowboydecoder.HotwordDetector(
self.model, sensitivity=0.5) # 设置语音模型与敏感度
print('Listening... Press Ctrl+Z to exit')
self.robot = Robot() # 创建应用模块
self.music_player = self.robot.get_music_player() # 创建音乐播放模块
self.player = Player() # 触发响应词叮咚播放
def signal_handler(self, signal, frame):
self.interrupted = True
def interrupt_callback(self):
return self.interrupted
def detected_callback(self):
self.music_player.pause() # 检测到人声时音乐暂停
self.player.play_ding() # 触发 叮
def speeched_callback(self, fname):
self.player.play_dong() # 检测时间到后触发 咚
self.robot.process(fname) # 将收到的语音传给应用模块执行相应的操作
sleep(1) # 等待片刻
self.music_player.cont() # 继续播放音乐
# 启动机器人
def run(self):
self.detector.start(detected_callback=self.detected_callback,
speeched_callback=self.speeched_callback,
interrupt_check=self.interrupt_callback,
sleep_time=0.03)
def __init__(self):
self.interrupted = False
# 读取配置
config_file = 'config.yaml'
if os.path.exists(config_file) == False:
print('【警告】配置文件不存在')
return
f = open('config.yaml')
config = yaml.load(f)
model_name = config.get('name', 'snowboy')
if ['snowboy','alexa'].count(model_name) > 0:
model_name = model_name + '.umdl'
else:
model_name = model_name + '.pmdl'
self.model = "唤醒词/" + model_name # 使用的语音模型
print('【唤醒词文件】' + self.model)
if os.path.exists(self.model) == False:
print('【警告】唤醒词文件不存在')
return
signal.signal(signal.SIGINT, self.signal_handler) # 捕获ctrl+c
self.detector = snowboydecoder.HotwordDetector(self.model, sensitivity=0.5) # 设置语音模型与敏感度
print('Listening... Press Ctrl+Z to exit')
self.robot = Robot(config) # 创建应用模块
self.player = Player() # 触发响应词叮咚播放
def test_invalid_input(self):
with captured_output() as (out, err):
robot = Robot()
robot.place(100, 100, "nowhere")
output = out.getvalue().strip()
self.assertEqual(output, "Invalid input.")
def __init__(self, sim=False):
# super(Core, self).__init__(sim)
Robot.__init__(self, sim)
# Qga.__init__(self, sim)
print("f**k end")
self.initialPoint = self.loc
dsrv = DynamicReconfigureServer(RobotConfig, self.Callback)
def test_falling_from_board(self):
with captured_output() as (out, err):
robot = Robot(4, 4, "east")
robot.move()
output = out.getvalue().strip()
self.assertEqual(output,
"Safety warning - I am about to fall to oblivion!")
def __init__(self):
self.interrupted = False
self.model = "嘿小二.pmdl" # 使用的语音模型
signal.signal(signal.SIGINT, self.signal_handler) # 捕获ctrl+c
self.detector = snowboydecoder.HotwordDetector(
self.model, sensitivity=0.5) # 设置语音模型与敏感度
print('Listening... Press Ctrl+Z to exit')
self.robot = Robot() # 创建应用模块
self.music_player = self.robot.get_music_player() # 创建音乐播放模块
self.player = Player() # 触发响应词叮咚播放
def __init__(self, map_filename, robot_filename):
self.robot = Robot()
self.world = FeatureBasedWorld()
self.tick = 0.0
self.pose_history = [] # ground truth trajectory
self.robot.LoadFromFile(robot_filename)
self.world.LoadFromFile(map_filename)
self.pose_history.append(self.robot.GetPose()) # initial pose
def __init__(self):
self.interrupted = False
self.model = "snowboy.pmdl"
signal.signal(signal.SIGINT, self.signal_handler)
self.detector = snowboydecoder.HotwordDetector(self.model,
sensitivity=0.42)
print('Listening... Press Ctrl+C to exit')
self.robot = Robot()
self.music_player = self.robot.get_music_player()
self.player = Player()
def setUp(self):
mock = self.create_mock_robotd()
mock.new_powerboard()
time.sleep(0.2)
self.mock = mock
self.robot = Robot(robotd_path=mock.root_dir,
wait_for_start_button=False)
def test_implicit_wait_start_competition_mode(self):
self.set_competition_mode()
with self.mock_kill_after_delay() as mock_kill_after_delay:
Robot(robotd_path=self.mock.root_dir)
mock_kill_after_delay.assert_called_once_with(
game_specific.GAME_DURATION_SECONDS, )
def setUp(self):
mock = self.create_mock_robotd()
# Insert a power board to let the robot start up
self.power_board = mock.new_powerboard()
time.sleep(0.2)
self.mock = mock
self.robot = Robot(robotd_path=mock.root_dir,
wait_for_start_button=False)
def test_explicit_wait_start_development_mode(self):
robot = Robot(
robotd_path=self.mock.root_dir,
wait_for_start_button=False,
)
with self.mock_kill_after_delay() as mock_kill_after_delay:
robot.power_board.wait_start()
# default is development mode, which doesn't have a timeout
mock_kill_after_delay.assert_not_called()
class Simulator:
# This class simulates a robot moving in a world. It updates the robot's
# state and measurements every tick.
def __init__(self, map_filename, robot_filename):
self.robot = Robot()
self.world = FeatureBasedWorld()
self.tick = 0.0
self.pose_history = [] # ground truth trajectory
self.robot.LoadFromFile(robot_filename)
self.world.LoadFromFile(map_filename)
self.pose_history.append(self.robot.GetPose()) # initial pose
def Update(self, t, action):
'''
Update the simulator.
===INPUT===
t: the time of update.
action: the active action from last Update() to t.
===OUTPUT===
A list of Measurement, which the robot observes at tick t.
'''
dt = t - self.tick
self.tick = t
rp = self.robot.ApplyAction(action, dt)
self.pose_history.append(rp)
return self.robot.MeasureWorld(self.world)
def GetTrajectory(self):
'''
Get the ground truth trajectory.
'''
return self.pose_history
def GetMap(self):
'''
Get the ground truth map.
'''
return self.world
def main(): robot = Robot((18,1), True) #robot.set_speed(100) #_real_map = Arena(robot) #ArenaUtils.load_arena_from_file(_real_map, 'map/SampleWeek11.txt') _explore_map = Arena(robot) _explore_map.set_allunexplored() CommMgr.connect() _explore = Exploration(_explore_map, robot, 300, 3600) _explore.run() CommMgr.close()
def test_two_clients(self):
""" Checks you can interface a motor board multiple times"""
# TODO make this test generic to the board, so it runs on all boards.
self.mock.new_motorboard('ABC')
# Set up robot 2!
robot2 = Robot(robotd_path=self.mock.root_dir,
wait_for_start_button=False)
# Give it a tiny bit to init the boards
time.sleep(0.2)
self.robot.motor_boards[0].m0 = 1
self.robot.motor_boards[0].m0 = -1
robot2.motor_boards[0].m0 = 1
robot2.motor_boards[0].m0 = -1
def run(self):
"""
Server start
"""
while True:
stacks = self.get_stacks()
if not stacks:
sleep(60)
continue
for stack in stacks:
result = Robot.run(stack)
self.send_result({'stack': stack, 'result': result})
def test_explicit_wait_start_competition_mode(self):
robot = Robot(
robotd_path=self.mock.root_dir,
wait_for_start_button=False,
)
self.set_competition_mode()
with self.mock_kill_after_delay() as mock_kill_after_delay:
robot.power_board.wait_start()
mock_kill_after_delay.assert_called_once_with(
game_specific.GAME_DURATION_SECONDS, )
def fp():
robot = Robot((18, 1), True)
_real_map = Arena(robot)
ArenaUtils.load_arena_from_file(_real_map, 'map/17_week10.txt')
print('Awaiting FP_START')
while True:
_command = CommMgr.recv()
if _command == 'FP_START':
CommMgr.send('X', CommMgr.ARDUINO)
break
_go_to_wp_goal = FastestPath(_real_map, robot)
_status = _go_to_wp_goal.do_fastest_path_wp_goal(
(7, 10), ArenaConstant.GOAL_POS.value)
def initialize_bots(gt, generator): global config bots = [] for i in range(config['num_bots']): sim = gt.get_hardware_instance(guid=i) bot = Robot(guid=i, ip=config['bots']['ip'], port=config['bots']['s_port']+i, hardware=sim, generator=generator, connect=config['bots']['connect'], image_size=config['sim']['image_size'] ) bots.append(bot) return bots
def main():
with tempfile.TemporaryDirectory(prefix="robot-api-test-") as root_dir:
mock = MockRobotD(root_dir=root_dir)
mock.new_powerboard()
time.sleep(0.2)
mock.new_motorboard()
time.sleep(0.2)
from robot.robot import Robot
robot = Robot(robotd_path=root_dir)
robot.power_board.power_off()
robot.motor_boards[0].m0 = 1
time.sleep(0.2)
mock.stop()
class SmartSpeaker():
# 初始化
def __init__(self):
self.interrupted = False
# 读取配置
config_file = 'config.yaml'
if os.path.exists(config_file) == False:
print('【警告】配置文件不存在')
return
f = open('config.yaml')
config = yaml.load(f)
model_name = config.get('name', 'snowboy')
if ['snowboy','alexa'].count(model_name) > 0:
model_name = model_name + '.umdl'
else:
model_name = model_name + '.pmdl'
self.model = "唤醒词/" + model_name # 使用的语音模型
print('【唤醒词文件】' + self.model)
if os.path.exists(self.model) == False:
print('【警告】唤醒词文件不存在')
return
signal.signal(signal.SIGINT, self.signal_handler) # 捕获ctrl+c
self.detector = snowboydecoder.HotwordDetector(self.model, sensitivity=0.5) # 设置语音模型与敏感度
print('Listening... Press Ctrl+Z to exit')
self.robot = Robot(config) # 创建应用模块
self.player = Player() # 触发响应词叮咚播放
def signal_handler(self, signal, frame):
self.interrupted = True
def interrupt_callback(self):
return self.interrupted
def detected_callback(self):
self.robot.hass_api('events/voice_assistant', {'type': 'ding'})
self.player.play_ding() # 触发 叮
def speeched_callback(self, fname):
self.player.play_dong() # 检测时间到后触发 咚
self.robot.process(fname) # 将收到的语音传给应用模块执行相应的操作
# sleep(1) # 等待片刻
self.robot.hass_api('events/voice_assistant', {'type': 'dong'})
# 启动机器人
def run(self):
self.detector.start(detected_callback=self.detected_callback, speeched_callback=self.speeched_callback,
interrupt_check=self.interrupt_callback,
sleep_time=0.03)
async def main():
opts = Options(sys.argv)
r = Robot(**opts.args())
try:
if opts.id is None:
"""Create new game if id was not specified"""
opts.id = await r.newgame()
else:
"""Check if game exists"""
if opts.id != await r.checkgame(opts.id):
print('Game id miss-matched', file=sys.stderr)
sys.exit(2)
except Exception as e:
print(f'Failed to acquire game: {e}')
sys.exit(3)
if opts.robots:
rbs = [r]
wrk = [ensure_future(r.run(pnum=opts.autoplay))]
await sleep(0.2) # Leader process should be able to reset game
for i in range(1, opts.robots):
r = Robot(uri=opts.site, idx=i, id=opts.id)
rbs.append(r)
wrk.append(ensure_future(r.run()))
await gather(*wrk)
results(wrk[0].result(), [r.pname for r in rbs],
[r.id_prefix for r in rbs])
else:
res = await r.run(pnum=opts.autoplay)
results(res)
from math import pi
import robot.api as api
import asyncio
config = ''
def load_config():
with open('config.yml') as f:
global config
config = yaml.load(f, Loader=yaml.FullLoader)
if __name__ == '__main__':
load_config()
robot = Robot(config['robot']['ip'])
asyncio.get_event_loop().run_until_complete(
robot.cmd_via_ws(api.CMD_START_SYS))
# 1. send cmd via http
print("========================================")
print("The following cmd was sent via http")
print("current robot mode: {}".format(robot.get_robot_mode()))
print(robot.get_target_joints())
print(robot.get_actual_joints())
print(robot.get_target_tcp_pose())
print(robot.get_actual_tcp_pose())
robot.move_check()
print(robot.movej([0, 0, 0, 0, 0, 0], True, 1, 1, 0))
print(robot.movej([0, -pi / 4, pi / 2, -pi / 4, pi / 2, 0], True, 1, 1, 0))
print(robot.movel([-0.3, -0.1, 0.2, -pi / 2, 0, pi / 2], False, 1, 1, 0))
def execute_path(self, path, goal_pos):
_output_string = []
_temp_block = path.pop()
_ori_target = None
_actions = []
_temp_robot = Robot(self._robot.get_pos(), False)
_temp_robot.set_ori(self._robot.get_ori())
_temp_robot.set_speed(0)
while _temp_robot.get_pos()[0] != goal_pos[0] or _temp_robot.get_pos(
)[1] != goal_pos[1]:
if _temp_robot.get_pos()[0] == _temp_block.get_pos(
)[0] and _temp_robot.get_pos()[1] == _temp_block.get_pos()[1]:
_temp_block = path.pop()
_ori_target = self.get_target_ori(_temp_robot.get_pos(),
_temp_robot.get_ori(),
_temp_block)
_action = None
if _temp_robot.get_ori() != _ori_target:
_action = self.get_target_move(_temp_robot.get_ori(),
_ori_target)
else:
_action = Action.FORWARD
print('Action {} from {} to {}'.format(_action.value,
_temp_robot.get_pos(),
_temp_block.get_pos()))
_temp_robot.move(_action)
_actions.append(_action)
_output_string.append(_action.value)
if not self._robot.is_actual_robot():
for _act in _actions:
if _act == Action.FORWARD:
if not self.can_move_forward():
print("Fastest Path Execution terminated!")
return "T"
self._robot.move(_act)
self._robot.notify(_act, self._map, True)
if self._exploration_mode:
self._robot.set_sensor()
self._robot.sense(self._map) #, self._real_map)
if self._surface is not None:
self._map.draw(self._surface)
else:
_fCount = 0
for _act in _actions:
if _act == Action.FORWARD:
_fCount += 1
if _fCount == 9:
self._robot.move_multiple(_fCount)
_fCount == 0
_command = 'F' + str(_fCount)
self._robot.notify(_command, self._map, True)
elif _act == Action.RIGHT or _act == Action.LEFT:
if _fCount > 0:
self._robot.move_multiple(_fCount)
_fCount == 0
_command = 'F' + str(_fCount)
self._robot.notify(_command, self._map, True)
self._robot.move(_act)
self._robot.notify(_act, self._map, True)
if _fCount > 0:
self._robot.move_multiple(_fCount)
_fCount == 0
_command = 'F' + str(_fCount)
self._robot.notify(_command, self._map, True)
print('Actions: {}'.format(''.join(_output_string)))
return ''.join(_output_string)
def test_implicit_wait_start_development_mode(self):
with self.mock_kill_after_delay() as mock_kill_after_delay:
Robot(robotd_path=self.mock.root_dir)
# default is development mode, which doesn't have a timeout
mock_kill_after_delay.assert_not_called()
config = toml.load(open("physics.toml", 'r'))
ppi = 2
height = config["field"]["height"]
width = config["field"]["width"]
field = np.zeros((width * ppi, height * ppi, 3))
robot_width = config["drivetrain"]["width"]
robot_length = config["drivetrain"]["length"]
robot_rot = config["robot"]["rot"]
robot_x = config["robot"]["x"]
robot_y = config["robot"]["y"]
drivetrain = DifferentialDrive(robot_width)
robot = Robot(drivetrain, robot_width * ppi, robot_length * ppi, position=[robot_x, robot_y], rotation=robot_rot)
dt = 0
last_time = datetime.now().microsecond / 1000000
while True:
simfield = np.copy(field)
robot.update(dt)
pts = np.array(robot.points, np.int32)
pts = pts.reshape((-1, 1, 2))
cv2.fillPoly(simfield, [pts], (0, 255, 255))
cv2.putText(simfield, f"L: {drivetrain.l_speed:.2f}", (15, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255))
cv2.putText(simfield, f"R: {drivetrain.r_speed:.2f}", (15, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255))
cv2.putText(simfield, f"F: {robot.forward:.2f}", (200, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255))
from robot.robot import Robot
from util.json_generator import generate_sample_obstacles
from util.json_parser import JSONParser
import numpy as np
# Generate the JSON file needed for obstacles
generate_sample_obstacles()
map_axis_size = 50
map_plane = np.zeros([map_axis_size, map_axis_size])
starting_location = [map_axis_size / 2, map_axis_size / 2]
robot = Robot(map_plane, JSONParser.get_obstacles(), starting_location)
# Human input movement
while (True):
user_input = input('Enter a movement command')
if user_input.lower() not in Robot.ALLOWED_MOVEMENTS:
print("Error: {} is not a recognized movement".format(user_input))
print("The allowed movements are {}.".format(Robot.ALLOWED_MOVEMENTS))
continue
robot.update_position(user_input)
import sys
from robot.robot import Robot
if __name__ == "__main__":
robot = Robot()
instruction_file = None
if len(sys.argv) > 1:
instruction_file = sys.argv[1]
result = robot.operate(instruction_file, debug=False)
distance = robot.nav.distance
def explore():
robot = Robot((18, 1), True)
_explore_map = Arena(robot)
_explore_map.set_allunexplored()
_explore = Exploration(_explore_map, robot, 300, 3600)
_explore.run()
