def run(coz_conn):
'''The run method runs once Cozmo is connected.'''
coz = coz_conn.wait_for_robot()
twitter_api, twitter_auth = twitter_helpers.init_twitter(twitter_keys)
stream_listener = CozmoReadsTweetsStreamListener(coz, twitter_api)
twitter_stream = twitter_helpers.CozmoStream(twitter_auth, stream_listener)
twitter_stream.userstream()
def run(coz_conn):
'''The run method runs once Cozmo is connected.'''
coz = coz_conn.wait_for_robot()
# Turn on image receiving by the camera
coz.camera.image_stream_enabled = True
twitter_api, twitter_auth = twitter_helpers.init_twitter(twitter_keys)
stream_listener = ReactToTweetsStreamListener(coz, twitter_api)
twitter_stream = twitter_helpers.CozmoStream(twitter_auth, stream_listener)
twitter_stream.userstream(_with='user')
def run(coz_conn):
'''The run method runs once Cozmo is connected.'''
coz = coz_conn.wait_for_robot()
stream_listener = CozmoReadsTweetsStreamListener(coz, twitter_api)
text_to_tweet = "I am now active on twitter"
coz.say_text(text_to_tweet).wait_for_completed()
date_time = datetime.datetime.now().strftime("%m-%d-%Y %I:%M")
twitter_helpers.post_tweet(twitter_api, f"{text_to_tweet} at {date_time}")
twitter_stream = twitter_helpers.CozmoStream(twitter_auth, stream_listener, coz, twitter_api)
twitter_stream.userstream()
async def desk_security_guard(robot):
'''The core of the desk_security_guard program'''
# Turn on image receiving by the camera
robot.camera.image_stream_enabled = True
# Connect Twitter, run async in the background
twitter_api, twitter_auth = twitter_helpers.init_twitter(twitter_keys)
stream_to_app_comms = TwitterStreamToAppCommunication()
stream_listener = SecurityGuardStreamListener(twitter_api, stream_to_app_comms)
twitter_stream = twitter_helpers.CozmoStream(twitter_auth, stream_listener)
twitter_stream.async_userstream(_with='user')
# Create our security guard
dsg = DeskSecurityGuard(twitter_api)
# Make sure Cozmo is clear of the charger
if robot.is_on_charger:
# Drive fully clear of charger (not just off the contacts)
await robot.drive_off_charger_contacts().wait_for_completed()
await robot.drive_straight(distance_mm(150), speed_mmps(50)).wait_for_completed()
# Tilt head up to look for people
await robot.set_head_angle(cozmo.robot.MAX_HEAD_ANGLE).wait_for_completed()
initial_pose_angle = robot.pose_angle
patrol_offset = 0 # middle
max_pose_angle = 45 # offset from initial pose_angle (up to +45 or -45 from this)
# Time to wait between each turn and patrol, in seconds
time_between_turns = 2.5
time_between_patrols = 20
time_for_next_turn = time.time() + time_between_turns
time_for_next_patrol = time.time() + time_between_patrols
while True:
# Handle any external requests to arm or disarm Cozmo
if stream_to_app_comms.has_arm_request:
stream_to_app_comms.has_arm_request = False
if not dsg.is_armed:
print("Alarm Armed")
dsg.is_armed = True
if stream_to_app_comms.has_disarm_request:
stream_to_app_comms.has_disarm_request = False
if dsg.is_armed:
print("Alarm Disarmed")
dsg.is_armed = False
stream_to_app_comms.is_armed = dsg.is_armed
# Turn head every few seconds to cover a wider field of view
# Only do this if not currently investigating an intruder
if (time.time() > time_for_next_turn) and not dsg.is_investigating_intruder():
# pick a random amount to turn
angle_to_turn = randint(10,40)
# 50% chance of turning in either direction
if randint(0,1) > 0:
angle_to_turn = -angle_to_turn
# Clamp the amount to turn
face_angle = (robot.pose_angle - initial_pose_angle).degrees
face_angle += angle_to_turn
if face_angle > max_pose_angle:
angle_to_turn -= (face_angle - max_pose_angle)
elif face_angle < -max_pose_angle:
angle_to_turn -= (face_angle + max_pose_angle)
# Turn left/right
await robot.turn_in_place(degrees(angle_to_turn)).wait_for_completed()
# Tilt head up/down slightly
await robot.set_head_angle(degrees(randint(30,44))).wait_for_completed()
# Queue up the next time to look around
time_for_next_turn = time.time() + time_between_turns
# Every now and again patrol left and right between 3 patrol points
if (time.time() > time_for_next_patrol) and not dsg.is_investigating_intruder():
# Check which way robot is facing vs initial pose, pick a new patrol point
face_angle = (robot.pose_angle - initial_pose_angle).degrees
drive_right = (patrol_offset < 0) or ((patrol_offset == 0) and (face_angle > 0))
# Turn to face the new patrol point
if drive_right:
await robot.turn_in_place(degrees(90 - face_angle)).wait_for_completed()
patrol_offset += 1
else:
await robot.turn_in_place(degrees(-90 - face_angle)).wait_for_completed()
patrol_offset -= 1
# Drive to the patrol point, playing animations along the way
await robot.drive_wheels(20, 20)
for i in range(1,4):
await robot.play_anim("anim_hiking_driving_loop_0" + str(i)).wait_for_completed()
# Stop driving
robot.stop_all_motors()
# Turn to face forwards again
face_angle = (robot.pose_angle - initial_pose_angle).degrees
if face_angle > 0:
await robot.turn_in_place(degrees(-90)).wait_for_completed()
else:
await robot.turn_in_place(degrees(90)).wait_for_completed()
# Queue up the next time to patrol
time_for_next_patrol = time.time() + time_between_patrols
# look for intruders
await check_for_intruder(robot, dsg)
# Sleep to allow other things to run
await asyncio.sleep(0.05)