def update_statistics(): def chunker(iterable, chunksize, filler): return izip_longest(*[iter(iterable)] * chunksize, fillvalue=filler) stats = Statistics() ids = [ i['session_key'] for i in models.SessionData.objects.filter( level__gte=0).values('session_key') ] for chunk in chunker(ids, 100, None): chunk = filter(None, chunk) for u in models.SessionData.objects.filter(pk__in=chunk): stats.add(u.json()) Settings.set('statistics', stats)
class NBackApp(App): SETTINGS_FILENAME = "config.ini" config = ObjectProperty(None) def build(self): self._load_settings() # TODO string should be accessed as constant db_dir = self.config.get('internal', 'db_path') db_location = os.path.join(db_dir, Statistics.DB_NAME) self.stats = Statistics(db_location) self.sm = ScreenHistoryManager() self.sm.add_widget(MainScreen(name='menu')) self.sm.add_widget(game.GameScreen(name='game')) self.sm.add_widget(settings.SettingScreen(name='settings')) self.sm.add_widget(statistics.StatisticsScreen(name='statistics')) self.sm.add_widget(about.AboutScreen(name='about')) Window.bind(on_keyboard=self._hook_keyboard) # return game return self.sm def add_result(self, level, position, shape, success, items_count): self.stats.add(level, position, shape, success, items_count) def _hook_keyboard(self, window, key, *args): if key in BACK_KEY_CODES: try: self.sm.move_to_previous_screen() except IndexError: self.stop() def _load_settings(self): self.config = ConfigParser() if not os.path.exists(self.SETTINGS_FILENAME): raise IOError("Cannot locate configuration file.") self.config.read(self.SETTINGS_FILENAME)
class Engrave: _APPROACH = 100 # Approach distance in mm IMAGE_SIZE_NONE = svg.Point(104, 50) # size of the image in MM not including edge IMAGE_SIZE_EDGE = svg.Point(100, 36) # size of image in MM not including edge IMAGE_SIZE_CURVED = svg.Point(108, 56) # size of image in MM not including edge stock = Stock() _PIXEL_SIZE = 1.2 # For calculating the arc length of the images def __init__(self, rdk): """ Constructor Checks whether an .svg file exist at the given location, if not loads a default .svg file and collects information from the config file """ # Check whether the customer has given a valid filepath, if not take the default .svg file if os.path.isfile(CaseConfig.file()): self.svg = svg.svg_load(CaseConfig.file()) else: self.svg = svg.svg_load(CaseConfig.file('DEFAULT')) # Initialize fields of the cover, robodk and statistics self.curve = CaseConfig.curve_style() self.color = CaseConfig.colour() self.RDK = rdk self.stat = Statistics() @staticmethod def point2d_2_pose(point, tangent): """ Translates a point to a point in 3D space :param point: Point object containing members x and y :param tangent: Tangent object containing method angle :return: Returns a 4 x 4 matrix of the point """ return transl(point.x, point.y, 0) * rotz(tangent.angle()) @staticmethod def curved_add_z(x): """ Calculates the z value depending on the x parameter Based on the function of the curvature on the curved cover :param x: x coordinate :return: the corresponding z coordinate """ x = fabs(x+23.3) y = pow(57, 2)-pow(x-57, 2) z = (8/57)*sqrt(y) return z def begin_flat(self, time: Timer): """ Engraving for flat covers Instructions sent to the robot in RoboDK for engraving the flat cover depending on the file given """ # Initialization of the robot, reference frame, tool and the pixel object and set the speed start = datetime.now() robot = self.RDK.Item('engraver', 2) robot.setSpeed(250) robot.setAcceleration(2000) item_frame = self.RDK.Item('engrave_flat', 3) tool_frame = self.RDK.Item('laser_tool', 4) pix_ref = self.RDK.Item('pixel', 5) # Move the phone into the environment self.move_to_environment() # Initialize the cover to engrave upon item = self.RDK.Item(f'cover_{self.color}_none_{self.stock.get(f"{self.color}_{self.curve}")+1}', 5) # Resize the svg to the engraveable surface on the cover self.svg.calc_polygon_fit(self.IMAGE_SIZE_NONE, self._PIXEL_SIZE) # Place the image centered on the cover based on the image size size_img = self.svg.size_poly() placement_var = -19+self.IMAGE_SIZE_NONE.x/2-size_img.x/2 # For each path in the svg for path in self.svg: # Align the image with the cover path.polygon_move(-25.5, placement_var) # Recolour the pixel to black and copy it for simulating engraving pix_ref.Recolor([0, 0, 0, 1]) pix_ref.Copy() # Get the first point on the image and switch it coordinates to get the correct rotation point_quantity = path.nPoints() point_0 = path.getPoint(0) point_0.switchXY() # Calculate a matrix for orienting the pose to the tool orient_frame2tool = invH(item_frame.Pose()) * robot.SolveFK(robot.JointsHome()) * tool_frame.Pose() orient_frame2tool[0:3, 3] = Mat([0, 0, 0]) # Get the first target, and align it with the tool and move the robot there target0 = transl(-point_0.x, point_0.y, -299) * orient_frame2tool * Pose(0, 0, 0, -180, 0, 270) robot.MoveL(target0) # Set the color in RoboDK self.RDK.RunProgram('SetColorRGB(%.3f,%.3f,%.3f)' % ( 0, 0, 0)) # For each point in the given path for point in range(point_quantity): # Get the point and switch the coordinates for correct rotation path_point = path.getPoint(point) path_point.switchXY() # Calculate the target based on the points, a height and orientation of the tool and move the engraver path_target = transl(-path_point.x, path_point.y, -299) * orient_frame2tool * Pose(0, 0, 0, -180, 0, 270) robot.MoveL(path_target) # create a new pixel object with the calculated pixel pose and add it to the cover point_pose = transl(-path_point.x + 5.2, 12, -path_point.y+67.55) * orient_frame2tool * Pose(0, 0, 0, 90, 0, 0) item.AddGeometry(pix_ref, point_pose) # Move to the end point robot.MoveL(path_target) # When done engraving move the robot home and move the phone out of the engraving environment # Note: the real home position of the engraver is very error prone as is therefore omitted from here robot.MoveJ(Pose(0, -23.3, -259, 0, 0, 90)) self.move_from_environment() # Add the engraving to the statistics stat_str = self.color + '_' + self.curve + '_engraved' self.stat.add(stat_str, 1) time.end('average_engraving_time', start) def begin_edge(self, time: Timer): """ Engraving for curved edges covers Instructions sent to the robot in RoboDK for engraving the curved edges cover depending on the file given """ # Initialization of the robot, reference frame, tool and the pixel object and start the timer start = datetime.now() robot = self.RDK.Item('engraver', 2) robot.setSpeed(250) robot.setAcceleration(2000) item_frame = self.RDK.Item('engrave_flat', 3) tool_frame = self.RDK.Item('laser_tool', 4) pix_ref = self.RDK.Item('pixel', 5) # Move the phone into the environment self.move_to_environment() # Initialize the cover to engrave upon item = self.RDK.Item(f'cover_{self.color}_edge_{self.stock.get(f"{self.color}_{self.curve}") + 1}', 5) # Resize the svg to the engraveable surface on the cover self.svg.calc_polygon_fit(self.IMAGE_SIZE_EDGE, self._PIXEL_SIZE) # Place the image centered on the cover based on the image size size_img = self.svg.size_poly() placement_var = -15+self.IMAGE_SIZE_EDGE.x/2-size_img.x/2 # For each path in the svg for path in self.svg: # Align the image with the cover path.polygon_move(-17, placement_var) # Recolour the pixel to black and copy it for simulating engraving pix_ref.Recolor([0, 0, 0, 1]) pix_ref.Copy() # Get the first point on the image and switch it coordinates to get the correct rotation point_quantity = path.nPoints() point_0 = path.getPoint(0) point_0.switchXY() # Calculate a matrix for orienting the pose to the tool orient_frame2tool = invH(item_frame.Pose()) * robot.SolveFK(robot.JointsHome()) * tool_frame.Pose() orient_frame2tool[0:3, 3] = Mat([0, 0, 0]) # Get the first target, and align it with the tool and move the robot there target0 = transl(-point_0.x, point_0.y, -296.38) * orient_frame2tool * Pose(0, 0, 0, -180, 0, 270) target0_app = target0 robot.MoveL(target0_app) # Set the color in RoboDK self.RDK.RunProgram('SetColorRGB(%.3f,%.3f,%.3f)' % ( 0, 0, 0)) # For each point in the given path for point in range(point_quantity): # Get the point and switch the coordinates for correct rotation path_point = path.getPoint(point) path_point.switchXY() # Calculate the target based on the points, a height and orientation of the tool and move the engraver path_target = transl(-path_point.x, path_point.y, -296.38) * orient_frame2tool * Pose(0, 0, 0, -180, 0, 270) robot.MoveL(path_target) # create a new pixel object with the calculated pixel pose and add it to the cover point_pose = transl(-path_point.x + 5.2, 14.75, -path_point.y + 67.55) * orient_frame2tool * Pose(0, 0, 0, 90, 0, 0) item.AddGeometry(pix_ref, point_pose) # Move to the end point robot.MoveL(path_target) # When done engraving move the robot home and move the phone out of the engraving environment # Note: the real home position of the engraver is very error prone as is therefore omitted from here robot.MoveJ(Pose(0, -23.3, -259, 0, 0, 90)) self.move_from_environment() # Add the engraving to the statistics stat_str = self.color + '_' + self.curve + '_engraved' self.stat.add(stat_str, 1) # End the timer with the engraving time and add it to the average time.end('average_engraving_time', start) def begin_curved(self, time: Timer): """ Engraving for curved covers Instructions sent to the robot in RoboDK for engraving the curved cover depending on the file given """ # Initialization of the robot, reference frame, tool and the pixel object and start the timer start = datetime.now() robot = self.RDK.Item('engraver', 2) robot.setSpeed(250) robot.setAcceleration(2000) item_frame = self.RDK.Item('engrave_flat', 3) tool_frame = self.RDK.Item('laser_tool', 4) pix_ref = self.RDK.Item('pixel', 5) # Move the phone into the environment self.move_to_environment() # Initialize the cover to engrave upon item = self.RDK.Item(f'cover_{self.color}_curved_{self.stock.get(f"{self.color}_{self.curve}")+1}', 5) # Resize the svg to the engraveable surface on the cover self.svg.calc_polygon_fit(self.IMAGE_SIZE_CURVED, self._PIXEL_SIZE) # Place the image centered on the cover based on the image size size_img = self.svg.size_poly() placement_var = -21.3+self.IMAGE_SIZE_CURVED.x/2-size_img.x/2 # For each path in the svg for path in self.svg: # Align the image with the cover path.polygon_move(-27.5, placement_var) # Recolour the pixel to black and copy it for simulating engraving pix_ref.Recolor([0, 0, 0, 1]) pix_ref.Copy() # Get the first point on the image and switch it coordinates to get the correct rotation point_quantity = path.nPoints() point_0 = path.getPoint(0) point_0.switchXY() # Calculate a matrix for orienting the pose to the tool orient_frame2tool = invH(item_frame.Pose()) * robot.SolveFK(robot.JointsHome()) * tool_frame.Pose() orient_frame2tool[0:3, 3] = Mat([0, 0, 0]) # Get the first target, and align it with the tool and move the robot there target0 = transl(-point_0.x, point_0.y, -302.1+self.curved_add_z(point_0.y)) * orient_frame2tool * Pose(0, 0, 0, -180, 0, 270) target0_app = target0 robot.MoveL(target0_app) # Set the color in RoboDK self.RDK.RunProgram('SetColorRGB(%.3f,%.3f,%.3f)' % ( 0, 0, 0)) # For each point in the given path for point in range(point_quantity): # Get the point and switch the coordinates for correct rotation path_point = path.getPoint(point) path_point.switchXY() # Calculate the target based on the points, a height and orientation of the tool and move the engraver path_target = transl(-path_point.x, path_point.y, -302.1 + self.curved_add_z(path_point.y)) * orient_frame2tool * Pose(0, 0, 0, -180, 0, 270) robot.MoveL(path_target) # create a new pixel object with the calculated pixel pose 20.67 point_pose = transl(-path_point.x + 5.2, 8.8+self.curved_add_z(path_point.y), -path_point.y +67.55) * orient_frame2tool * Pose(0, 0, 0, 90, 0, 0) # create a new pixel object with the calculated pixel pose and add it to the cover item.AddGeometry(pix_ref, point_pose) # Move to the end point robot.MoveL(path_target) # When done engraving move the robot home and move the phone out of the engraving environment # Note: the real home position of the engraver is very error prone as is therefore omitted from here robot.MoveJ(Pose(0, -23.3, -259, 0, 0, 90)) self.move_from_environment() # Add the engraving to the statistics stat_str = self.color + '_' + self.curve + '_engraved' self.stat.add(stat_str, 1) # End the timer with the engraving time and add it to the average time.end('average_engraving_time', start) def move_to_environment(self): """ Moves the cover into the engraving environment with the engraving plate """ # Initialize the moving_plate and its reference frame and set the speed robot = self.RDK.Item('moving_plate') plate_ref = self.RDK.Item('engraving_plate_ref', 3) robot.setSpeed(300) # Set the position of the engraving plate, set the reference frame of the plate and move it to the position position_engraving = Pose(318, 0, 16.3, 0, 0, 0) robot.setPoseFrame(plate_ref) robot.MoveL(position_engraving) def move_from_environment(self): """ Moves the cover from the engraving environment with the engraving plate """ # Initialize the moving_plate and its reference frame and set the speed robot = self.RDK.Item('moving_plate') plate_ref = self.RDK.Item('engraving_plate_ref', 3) robot.setSpeed(300) # Set the position of the engraving plate, set the reference frame of the plate and move it to the position position_engraving_out = Pose(145, 0, 16.3, 0, 0, 0) robot.setPoseFrame(plate_ref) robot.MoveL(position_engraving_out)
class Cover: # Global class variables # Distances in mm # Offsets for positions of covers in the storage container _OFFSETZ_NONE = 50.25 _OFFSETZ_EDGE = 25 _OFFSETZ_CURVED = 4.4 _OFFSETX_COVER_DIST = 70 _OFFSETY_COVER_DIST = 73 _APPROACH = 100 # Cover related offsets for calculations _OFFSETZ_COVER_FLAT_DIST = 11.7 _OFFSETZ_COVER_EDGE_DIST = 14.7 _OFFSETZ_COVER_CURVED_DIST = 16.7 _TOP_COVER_INDENT_OFFSET = 5 _BOTTOM_COVER_HEIGHT = 13 # Colours for recolouring the bottom cover _COLOR_BLACK = [0.1019607843, 0.1019607843, 0.1019607843] _COLOR_WHITE = [1, 1, 1] _COLOR_BLUE = [0, 0, 0.6078431372] def __init__(self, color, curve_type, stock: Stock): """ Constructor: Assigns the parameters to the given fields and corrects the position of the cover based on the parameters :param color: The color given in the config file :param curve_type: The curve type given in the config file :param stock: Stock Stock controlling object with type hint Stock """ # Initialization of important object fields self.RDK = Robolink() self.color = color self.curve = curve_type self.stock = stock self.stat = Statistics() # Initial position of the first set of covers self.position = Pose(45.5, self._OFFSETY_COVER_DIST, 0, -180, 0, 0) # Correct the position of the cover based on colour and curvature self.correct_pos(self.stock) # Initialize bottom cover as RoboDK Item for recolouring bottom = self.RDK.Item('bottom', 5) # Based on selection of colour, recolour bottom cover if CaseConfig.bottom_colour() == 'black': bottom.Recolor(self._COLOR_BLACK) if CaseConfig.bottom_colour() == 'white': bottom.Recolor(self._COLOR_WHITE) if CaseConfig.bottom_colour() == 'blue': bottom.Recolor(self._COLOR_BLUE) def correct_pos(self, stock: Stock): """ Corrects the position of the cover relative to the stock container, depending on the type of cover. Instead of giving each cover a static position :param stock: Stock controlling object with type hint Stock :return: The position of the specific cover """ # Dicts with identifiers for easier calculation of position curve_types = { 'black_none': 0, 'black_edge': 3, 'black_curved': 6, 'white_none': 1, 'white_edge': 4, 'white_curved': 7, 'blue_none': 2, 'blue_edge': 5, 'blue_curved': 8 } case_types = { 'black_none': 0, 'black_edge': 1, 'black_curved': 2, 'white_none': 3, 'white_edge': 4, 'white_curved': 5, 'blue_none': 6, 'blue_edge': 7, 'blue_curved': 8 } case_curve = {'curved': 0, 'edge': 1, 'none': 2} # Apply the offset from the bottom of the container to the first cover in the pile curvature = case_curve[f'{self.curve}'] if curvature == 1: self.position[2, 3] = self.position[2, 3] + self._OFFSETZ_EDGE if curvature == 2: self.position[2, 3] = self.position[2, 3] + self._OFFSETZ_NONE if curvature == 0: self.position[2, 3] = self.position[2, 3] + self._OFFSETZ_CURVED # Apply the x-offset based on the type and the colour of the cover identifier = case_types[f'{self.color}_{self.curve}'] self.position[ 0, 3] = self.position[0, 3] + identifier * self._OFFSETX_COVER_DIST # Depending on the remaining stock and type of curve, calculate the Z-offset to compensate for the empty space identifier_curve = curve_types[f'{self.color}_{self.curve}'] if identifier_curve in range(0, 3): self.position[2, 3] = self.position[2, 3] + stock.get( f'{self.color}_none') * self._OFFSETZ_COVER_FLAT_DIST if identifier_curve in range(3, 6): self.position[2, 3] = self.position[2, 3] + stock.get( f'{self.color}_edge') * self._OFFSETZ_COVER_EDGE_DIST if identifier_curve in range(6, 9): self.position[2, 3] = self.position[2, 3] + stock.get( f'{self.color}_curved') * self._OFFSETZ_COVER_CURVED_DIST def __str__(self): """ String representation of the class :return: Prints the color, curve type and position of the cover """ print(f'{self.color} curve_{self.curve} cover at {self.position}') def get_pos(self): """ Debugging method :return: Returns the position of the cover """ return self.position def grab(self, robot): """ Method that sends instructions to the robot in RoboDK to grab the cover from the stock container :param robot: Robot object representing the robot in RoboDK """ # Initialize the reference frame as an Item to use in positioning frame = self.RDK.Item('storage', 3) # Set the reference frame to the newly initialized frame robot.setPoseFrame(frame) robot.setSpeed(900) # Copy the initial position and apply an offset to ensure the same approach each time and move the robot there position_copy = self.position if self.curve == 'none': position_copy[2, 3] = position_copy[ 2, 3] + self._APPROACH + self.stock.get_init( ) * self._OFFSETZ_COVER_FLAT_DIST elif self.curve == 'edge': position_copy[2, 3] = position_copy[ 2, 3] + self._APPROACH + self.stock.get_init( ) * self._OFFSETZ_COVER_EDGE_DIST elif self.curve == 'curved': position_copy[2, 3] = position_copy[ 2, 3] + self._APPROACH + self.stock.get_init( ) * self._OFFSETZ_COVER_CURVED_DIST robot.MoveJ(position_copy) # Reduce the speed and subtract all the height offsets to approach cover and move robot to the given position robot.setSpeed(300) if self.curve == 'none': position_copy[2, 3] = position_copy[ 2, 3] - self._APPROACH - self.stock.get_init( ) * self._OFFSETZ_COVER_FLAT_DIST elif self.curve == 'edge': position_copy[2, 3] = position_copy[ 2, 3] - self._APPROACH - self.stock.get_init( ) * self._OFFSETZ_COVER_EDGE_DIST elif self.curve == 'curved': position_copy[2, 3] = position_copy[ 2, 3] - self._APPROACH - self.stock.get_init( ) * self._OFFSETZ_COVER_CURVED_DIST robot.MoveL(position_copy) # Run RoboDk program to attach cover to tool self.RDK.RunProgram('Prog6') # Return to the approach position to ensure that the robot doesn't damage anything else and move there if self.curve == 'none': position_copy[2, 3] = position_copy[ 2, 3] + self._APPROACH + self.stock.get_init( ) * self._OFFSETZ_COVER_FLAT_DIST elif self.curve == 'edge': position_copy[2, 3] = position_copy[ 2, 3] + self._APPROACH + self.stock.get_init( ) * self._OFFSETZ_COVER_EDGE_DIST elif self.curve == 'curved': position_copy[2, 3] = position_copy[ 2, 3] + self._APPROACH + self.stock.get_init( ) * self._OFFSETZ_COVER_CURVED_DIST robot.MoveL(position_copy) # Add the used cover to statistics for later collection of data self.stock.sub(f'{self.color}_{self.curve}', 1) def give_top(self, time: Timer): """ Sends instructions to RoboDK to grab a cover, place it on top of the bottom cover if the cover needs to be engraved, places it on the engraving plate. """ # Start the timer start = datetime.now() # Carrier positions in relation to it's reference frame carrier_offsetx = 88.7 # (Carrier length / 2) carrier_offsety = 55.3 # (Carrier width / 2) carrier_offsetz = 42.3 # (Carrier depth) # Initialization of position of carrier and adding approach distance carrier_position_app = Pose(carrier_offsetx, carrier_offsety, carrier_offsetz, -180, 0, -90) carrier_position_app[2, 3] = carrier_position_app[2, 3] + self._APPROACH # Ensure connections to RoboDK self.RDK.Connect() # Connect to the robot and initialize pickup procedure robot = self.RDK.Item('fanuc', 2) self.grab(robot) robot.setSpeed(900) # Create object frame for usage as reference frame carrier_ = self.RDK.Item('carrier', 3) # Assign reference frame to robot and move to position robot.setPoseFrame(carrier_) robot.MoveJ(carrier_position_app) # Initialize new position variable with previous position position_withoffset = carrier_position_app # Check the type of cover again and subtract the approach offset and detail offset, # while considering that a cover is attached to the tool if self.curve == 'none': position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._APPROACH + self._OFFSETZ_COVER_FLAT_DIST - 1.5 if self.curve == 'edge': position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._APPROACH + self._OFFSETZ_COVER_EDGE_DIST - 1.77 if self.curve == 'curved': position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._APPROACH + self._OFFSETZ_COVER_CURVED_DIST - 2.4 # Take into account that it is now a whole phone position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._TOP_COVER_INDENT_OFFSET + self._BOTTOM_COVER_HEIGHT # Reduce speed for safety and move to position robot.setSpeed(300) robot.MoveL(position_withoffset) # Run program named Prog7 to attach bottom cover to tool self.RDK.RunProgram('Prog7') # Add the creation of the phone to statistics self.stat.add(f'{self.color}_{self.curve}', 1) # If the cover needs engraving if CaseConfig.engrave(): # End the timer and add it to the production time average time.end('average_production_time', start) # Add approach distance to the position and move the robot there and reset the speed carrier_position_app[2, 3] = carrier_position_app[2, 3] + self._APPROACH robot.MoveL(carrier_position_app) robot.setSpeed(900) # Create frame object for reference frame and assign it to the robot engrave_plate_ref = self.RDK.Item('engraving_plate_ref', 3) robot.setPoseFrame(engrave_plate_ref) # Initialize the position of the engraving plate engrave_plate_pos_app = Pose(145.29, 0.05, 42.6, -180, 0, 90) # Check for type of cover an apply an approach to the z value and move the robot there if self.curve == 'none': engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH if self.curve == 'edge': engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH + 3 if self.curve == 'curved': engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH + 5 robot.MoveJ(engrave_plate_pos_app) # Initialize new position variable and check for cover type and subtract the approach while taking into account carrying a phone engrave_plate_pos = engrave_plate_pos_app robot.setSpeed(300) if self.curve == 'none': engrave_plate_pos[2, 3] = engrave_plate_pos[2, 3] - self._APPROACH elif self.curve == 'edge': engrave_plate_pos[ 2, 3] = engrave_plate_pos[2, 3] - self._APPROACH - 2 else: engrave_plate_pos[ 2, 3] = engrave_plate_pos[2, 3] - self._APPROACH - 2.5 robot.MoveL(engrave_plate_pos) # Create tool object and detach all children of this object tool_suction_ = self.RDK.Item('tool_suction', 4) tool_suction_.DetachAll() # Detach all objects from the robot # Check the type of cover and apply approach distance and move the robot there if self.curve == 'none': engrave_plate_pos[2, 3] = engrave_plate_pos[2, 3] + self._APPROACH elif self.curve == 'edge': engrave_plate_pos[ 2, 3] = engrave_plate_pos[2, 3] + self._APPROACH - 2 else: engrave_plate_pos[ 2, 3] = engrave_plate_pos[2, 3] + self._APPROACH - 2.5 robot.MoveL(engrave_plate_pos) # Move the robot home and attach the phone to the engraving plate by running the program "prog8" robot.setSpeed(900) robot.MoveJ(robot.JointsHome()) self.RDK.RunProgram('Prog8') # If the cover doesn't need engraving else: # End the timer and add it to the production time average time.end('average_production_time', start) # Create a tool object and Detach all children from it tool_suction_ = self.RDK.Item('tool_suction', 4) tool_suction_.DetachAll() # Apply approach distance and move the robot there carrier_position_app[2, 3] = carrier_position_app[2, 3] + self._APPROACH robot.MoveL(carrier_position_app) # Reset speed and move the robot to it's home position robot.setSpeed(900) robot.MoveJ(robot.JointsHome()) def retrieve(self): """ Retrieves the cover from the engraving plate and places it on the pallette Thereby finishing the production of an engraved cover """ # Initialize moving plate tool object and detach all children of the object. move_plate_tool = self.RDK.Item('engraving_plate', 4) move_plate_tool.DetachAll() # Initialize the reference frame of the engraving plate, the robot and set the robot reference frame to the # frame of the engraving plate and set the speed engrave_plate_ref = self.RDK.Item('engraving_plate_ref', 3) robot = self.RDK.Item('fanuc', 3) robot.setPoseFrame(engrave_plate_ref) robot.setSpeed(900) # Initialize the position of the engraving plate engrave_plate_pos_app = Pose(145.29, 0.05, 42.5, -180, 0, 90) # Apply approach distance to the position and move the robot there if self.curve == 'none': engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH elif self.curve == 'edge': engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH else: engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH robot.MoveJ(engrave_plate_pos_app) # Initialize new position variable with the old and subtract the approach distance along with an offset robot.setSpeed(300) engrave_plate_pos = engrave_plate_pos_app if self.curve == 'none': engrave_plate_pos[2, 3] = engrave_plate_pos[2, 3] - self._APPROACH - 0.25 elif self.curve == 'edge': engrave_plate_pos[2, 3] = engrave_plate_pos[2, 3] - self._APPROACH + 1.6 else: engrave_plate_pos[2, 3] = engrave_plate_pos[2, 3] - self._APPROACH + 3.0 # Move the robot to the new position and attach the phone to it robot.MoveL(engrave_plate_pos) self.RDK.RunProgram('Prog6') self.RDK.RunProgram('Prog7') # Apply approach distance to the position and move the robot there if self.curve == 'none': engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH elif self.curve == 'edge': engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH else: engrave_plate_pos_app[ 2, 3] = engrave_plate_pos_app[2, 3] + self._APPROACH robot.MoveJ(engrave_plate_pos_app) # Cover position coordinates relative to the carrier reference frame reference frame carrier_offsetx = 88.7 # (Carrier length / 2) carrier_offsety = 55.3 # (Carrier width / 2) carrier_offsetz = 42.3 # (Carrier depth) # Initialize position field with position of the carrier carrier_position_app = Pose(carrier_offsetx, carrier_offsety, carrier_offsetz, -180, 0, -90) # Initialize frame object of the carrier and set the reference frame of the robot to the given frame carrier_ = self.RDK.Item('carrier', 3) robot.setPoseFrame(carrier_) robot.setSpeed(900) # Apply the approach distance to the position and move the robot there if self.curve == 'none': carrier_position_app[2, 3] = carrier_position_app[2, 3] + self._APPROACH if self.curve == 'edge': carrier_position_app[2, 3] = carrier_position_app[2, 3] + self._APPROACH if self.curve == 'curved': carrier_position_app[2, 3] = carrier_position_app[2, 3] + self._APPROACH robot.MoveJ(carrier_position_app) # Initialize new position field position_withoffset = carrier_position_app # Check the type of cover again and subtract the approach offset, # while considering that a cover is attached to the tool robot.setSpeed(300) if self.curve == 'none': position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._APPROACH + self._OFFSETZ_COVER_FLAT_DIST - 1.85 if self.curve == 'edge': position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._APPROACH + self._OFFSETZ_COVER_EDGE_DIST - 1.27 if self.curve == 'curved': position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._APPROACH + self._OFFSETZ_COVER_CURVED_DIST - 2 # Take into account that it is now a whole phone and move the robot to the position position_withoffset[2, 3] = position_withoffset[ 2, 3] - self._TOP_COVER_INDENT_OFFSET + self._BOTTOM_COVER_HEIGHT robot.MoveL(position_withoffset) # Initialize the tool and detach all children of the tool and move the robot home tool_suction_ = self.RDK.Item('tool_suction', 4) tool_suction_.DetachAll() robot.setSpeed(900) robot.MoveJ(robot.JointsHome()) def new_cover_check(self): """ Checks if any cover is remaining from earlier run-throughs and deletes them :return: Deletion of previous covers """ # Dict containing all cover types cover_types = { 0: 'black_none', 1: 'black_edge', 2: 'black_curved', 3: 'white_none', 4: 'white_edge', 5: 'white_curved', 6: 'blue_none', 7: 'blue_edge', 8: 'blue_curved' } # Check all types for previous covers by checking stock for key in cover_types: item = self.RDK.Item( f'cover_{cover_types[key]}_{self.stock.get(f"{cover_types[key]}") + 1}' ) if item.Valid(): item.Delete()
agent.save() break print(time.time() - t0) else: envs_to_test = config['test']['envs'] for env in envs_to_test: methods = config['test']['methods'] assert len(methods) > 0 for method in methods: number_of_tests = config['test']['number'] for i in range(number_of_tests): tf.reset_default_graph() current_agent = get_agent(method, config, env) for _ in range(current_agent.max_episodes): step(current_agent) logger.log(current_agent.eps_reward) if current_agent.episode % 100 == 0: current_agent.save() stats.add(current_agent, env) # pickle.dump(current_agent.q_vals, open('q_vals_dqn.pkl', 'wb')) logger.reset() stats.save() stats.visualise()