def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>', ApiTeamHistoryRobotsController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc1124",
name="UberBots",
team_number=1124,
nickname="UberBots",
)
self.robot = Robot(
id="frc1124_2015",
team=self.team.key,
year=2015,
robot_name="Orion"
)
self.team.put()
self.robot.put()
def parse(self, response):
"""
Parse team info from FMSAPI
Returns a tuple of: list of models (Team, DistrictTeam, Robot),
and a Boolean indicating if there are more pages to be fetched
"""
# Get team json
# don't need to null check, if error, HTTP code != 200, so we wont' get here
current_page = response['pageCurrent']
total_pages = response['pageTotal']
teams = response['teams']
ret_models = []
for teamData in teams:
# Fix issue where FIRST's API returns dummy website for all teams
if teamData[
'website'] is not None and 'www.firstinspires.org' in teamData[
'website']:
website = None
else:
raw_website = teamData.get('website', None)
website = urlparse.urlparse(
raw_website, 'http').geturl() if raw_website else None
# Fix oddity with urlparse having three slashes after the scheme (#1635)
website = website.replace('///', '//') if website else None
team = Team(id="frc{}".format(teamData['teamNumber']),
team_number=teamData['teamNumber'],
name=teamData['nameFull'],
nickname=teamData['nameShort'],
city=teamData['city'],
state_prov=teamData['stateProv'],
country=teamData['country'],
website=website,
rookie_year=teamData['rookieYear'])
districtTeam = None
if teamData['districtCode']:
districtAbbrev = DistrictType.abbrevs[
teamData['districtCode'].lower()]
districtTeam = DistrictTeam(id=DistrictTeam.renderKeyName(
self.year, districtAbbrev, team.key_name),
team=ndb.Key(Team, team.key_name),
year=self.year,
district=districtAbbrev)
robot = None
if teamData['robotName']:
robot = Robot(id=Robot.renderKeyName(team.key_name, self.year),
team=ndb.Key(Team, team.key_name),
year=self.year,
robot_name=teamData['robotName'].strip())
ret_models.append((team, districtTeam, robot))
return (ret_models, (current_page < total_pages))
def parse(self, response):
"""
Parse team info from FMSAPI
Returns a tuple of: list of models (Team, DistrictTeam, Robot),
and a Boolean indicating if there are more pages to be fetched
"""
# Get team json
# don't need to null check, if error, HTTP code != 200, so we wont' get here
current_page = response['pageCurrent']
total_pages = response['pageTotal']
teams = response['teams']
ret_models = []
for teamData in teams:
# Fix issue where FIRST's API returns dummy website for all teams
if teamData[
'website'] is not None and 'www.firstinspires.org' in teamData[
'website']:
website = None
else:
website = WebsiteHelper.format_url(
teamData.get('website', None))
team = Team(id="frc{}".format(teamData['teamNumber']),
team_number=teamData['teamNumber'],
name=teamData['nameFull'],
nickname=teamData['nameShort'],
school_name=teamData.get('schoolName'),
home_cmp=teamData.get('homeCMP').lower()
if teamData.get('homeCMP') else None,
city=teamData['city'],
state_prov=teamData['stateProv'],
country=teamData['country'],
website=website,
rookie_year=teamData['rookieYear'])
districtTeam = None
if teamData['districtCode']:
districtKey = District.renderKeyName(
self.year, teamData['districtCode'].lower())
districtTeam = DistrictTeam(
id=DistrictTeam.renderKeyName(districtKey, team.key_name),
team=ndb.Key(Team, team.key_name),
year=self.year,
district_key=ndb.Key(District, districtKey),
)
robot = None
if teamData['robotName']:
robot = Robot(id=Robot.renderKeyName(team.key_name, self.year),
team=ndb.Key(Team, team.key_name),
year=self.year,
robot_name=teamData['robotName'].strip())
ret_models.append((team, districtTeam, robot))
return (ret_models, (current_page < total_pages))
def post_robot():
try:
data = json.loads(request.get_data())
robot = Robot(**data)
except:
return "Your model sucks"
db.session.add(robot)
db.session.commit()
return robot.id
def create_robot(user):
if not user:
return jsonify({'message': 'Not authorized'}), 401
current_location_x = request.json.get('current_location_x', 0)
current_location_y = request.json.get('current_location_y', 0)
mac_address = request.json.get('mac_address')
robot = Robot(current_location_x, current_location_y, mac_address)
robot.save_to_db()
response = robot.serialize
return jsonify(response), 201
def parse(self, response):
"""
Parse team info from FMSAPI
Returns a tuple of: list of models (Team, DistrictTeam, Robot),
and a Boolean indicating if there are more pages to be fetched
"""
# Get team json
# don't need to null check, if error, HTTP code != 200, so we wont' get here
current_page = response['pageCurrent']
total_pages = response['pageTotal']
teams = response['teams']
ret_models = []
for teamData in teams:
# concat city/state/country to get address
address = u"{}, {}, {}".format(teamData['city'],
teamData['stateProv'],
teamData['country'])
team = Team(id="frc{}".format(teamData['teamNumber']),
team_number=teamData['teamNumber'],
name=teamData['nameFull'],
nickname=teamData['nameShort'],
address=address,
website=teamData['website'],
rookie_year=teamData['rookieYear'])
districtTeam = None
if teamData['districtCode']:
districtAbbrev = DistrictType.abbrevs[
teamData['districtCode'].lower()]
districtTeam = DistrictTeam(id=DistrictTeam.renderKeyName(
self.year, districtAbbrev, team.key_name),
team=ndb.Key(Team, team.key_name),
year=self.year,
district=districtAbbrev)
robot = None
if teamData['robotName']:
robot = Robot(id=Robot.renderKeyName(team.key_name, self.year),
team=ndb.Key(Team, team.key_name),
year=self.year,
robot_name=teamData['robotName'].strip())
ret_models.append((team, districtTeam, robot))
return (ret_models, (current_page < total_pages))
def post(self):
team_number = self.request.get("team_number")
if not team_number:
self.abort(400)
team_number = int(team_number)
team = Team.get_by_id("frc{}".format(team_number))
if not team:
self.abort(400)
self._require_team_admin_access(team_number)
action = self.request.get('action')
if action == "remove_media_reference":
media, team_ref = self.get_media_and_team_ref(team_number)
if team_ref in media.references:
media.references.remove(team_ref)
if team_ref in media.preferred_references:
media.preferred_references.remove(team_ref)
MediaManipulator.createOrUpdate(media, auto_union=False)
elif action == "remove_media_preferred":
media, team_ref = self.get_media_and_team_ref(team_number)
if team_ref in media.preferred_references:
media.preferred_references.remove(team_ref)
MediaManipulator.createOrUpdate(media, auto_union=False)
elif action == "add_media_preferred":
media, team_ref = self.get_media_and_team_ref(team_number)
if team_ref not in media.preferred_references:
media.preferred_references.append(team_ref)
MediaManipulator.createOrUpdate(media, auto_union=False)
elif action == "set_team_info":
robot_name = self.request.get("robot_name").strip()
current_year = datetime.datetime.now().year
robot_key = Robot.renderKeyName(team.key_name, current_year)
if robot_name:
robot = Robot(
id=robot_key,
team=team.key,
year=current_year,
robot_name=robot_name,
)
RobotManipulator.createOrUpdate(robot)
else:
RobotManipulator.delete_keys([ndb.Key(Robot, robot_key)])
else:
self.abort(400)
self.redirect('/mod/')
def test_delete_robot_name(self):
self.loginUser()
self.giveTeamAdminAccess()
Robot(
id=Robot.renderKeyName(self.team.key_name, self.now.year),
team=self.team.key,
year=self.now.year,
robot_name='First Robot Name',
).put()
form = self.getTeamInfoForm(1124)
self.assertEqual(form['robot_name'].value, 'First Robot Name')
form['robot_name'] = ''
response = form.submit().follow()
self.assertEqual(response.status_int, 301)
robot = Robot.get_by_id(Robot.renderKeyName('frc1124', self.now.year))
self.assertIsNone(robot)
def post(self):
self._require_admin()
team_key = self.request.get('team_key')
year = int(self.request.get('robot_year'))
name = self.request.get('robot_name')
team = Team.get_by_id(team_key)
if not team:
self.abort(404)
if not year or not name:
self.abort(400)
robot = Robot(id=Robot.renderKeyName(team_key, year),
team=team.key,
year=year,
robot_name=name.strip())
RobotManipulator.createOrUpdate(robot)
self.redirect('/admin/team/{}'.format(team.team_number))
def initialize_sim(self, random=False):
# reset the viewer
self.viewer.control_panel_state_init()
# create the simulation world
self.world = World(self.period)
# create the robot
robot = Robot()
self.world.add_robot(robot)
# generate a random environment
if random:
self.map_manager.random_map(self.world)
else:
self.map_manager.apply_to_world(self.world)
# create the world view
self.world_view = WorldView(self.world, self.viewer)
# render the initial world
self.draw_world()
lightred1 = np.array([0, 100, 20])
darkred1 = np.array([5, 255, 255])
lightred2 = np.array([175, 100, 20])
darkred2 = np.array([179, 255, 255])
lightblue = np.array([100, 100, 20])
darkblue = np.array([125, 255, 255])
lightgreen = np.array([40, 50, 50])
darkgreen = np.array([80, 255, 255])
robot = Robot(vrep,
client_id,
name='Pioneer_p3dx{}'.format(sufix),
name_motor_left='Pioneer_p3dx_leftMotor{}'.format(sufix),
name_motor_right='Pioneer_p3dx_rightMotor{}'.format(sufix),
name_camera='Vision_sensor{}'.format(sufix),
name_prox_sensor='Proximity_sensor{}'.format(sufix),
name_payload='Payload{}'.format(sufix),
velocity=VELOCITY_SLOW,
velocity_rotation=VELOCITY_ROTATION_SLOW,
tork=TORK_SLOW,
tork_rotation=TORK_ROTATE_SLOW,
error=ERROR)
def shaped(mask, color):
contours, _ = cv2.findContours(mask, cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
for cont in contours:
area = cv2.contourArea(cont)
approx = cv2.approxPolyDP(cont, 0.01 * cv2.arcLength(cont, True), True)
x = approx.ravel()[0]
from uploader import Uploader
from models.map import Map
from models.robot import Robot
from settings import MONGO_URI
mongo = MongoClient(MONGO_URI)
db = mongo.ways_db
mapper = Map()
up = Uploader(db, mapper)
if __name__ == "__main__":
loop = asyncio.get_event_loop()
filename = input("type here name of file with map: ")
try:
up.upload(filename)
except FileNotFoundError:
print('Wrong filename')
sys.exit()
tasks = [
loop.create_task(Robot().walking(route.get('map', {}).get('data')))
for route in db.ways.find({})
]
try:
loop.run_until_complete(asyncio.wait(tasks))
except ValueError:
print('No routs found')
finally:
loop.close()
def get(self):
robots = Robot.get()
parsed_robots = [Robot(robot['name']).json() for robot in robots]
return parsed_robots, 200 if parsed_robots else 402
def get(self, robot_id):
robot = Robot.get_by_id(robot_id)
parsed_robot = Robot(robot['name']).json()
return parsed_robot, 200 if parsed_robot else 402
def post_robot():
data = json.loads(request.get_data())
robot = Robot(**data)
import socket
import time
from pysabertooth import Sabertooth
from models.robot import Robot
from models.camera import Camera
from multiprocessing import Process
PORT = "/dev/serial/by-id/usb-FTDI_FT232R_USB_UART_A105QI4I-if00-port0"
saber = Sabertooth(PORT, baudrate=9600, address=128, timeout=0.1)
robot = Robot(saber)
camera = Camera('test_1', "./data/")
client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client_socket.connect(("192.168.0.9", 8000))
button_delay = 0.2
try:
while True:
from_server = client_socket.recv(4096)
char = from_server.decode("utf-8")
if char == "p":
print("Stoping robot")
robot.stop()
time.sleep(1)
camera.done()
exit(0)
if char == "c":
robot.stop()
time.sleep(button_delay)
