def create(config, profile_dir): driver = S3gDriver(config, profile_dir) for profile_name in makerbot_driver.list_profiles(profile_dir): s3g_profile = makerbot_driver.Profile(profile_name, profile_dir) profile = _S3gProfile._create(profile_name, driver, s3g_profile) driver._profiles[profile.name] = profile return driver
def build_from_port(self, portname, leaveOpen=True): """ Returns a tuple of an (s3gObj, ProfileObj) for a bot at port portname """ machineInquisitor = self.create_inquisitor(portname) s3gBot, bot_setup_dict = machineInquisitor.query(leaveOpen) profile_regex = self.get_profile_regex(bot_setup_dict) matches = makerbot_driver.search_profiles_with_regex( profile_regex, self.profile_dir) matches = list(matches) return_object = ReturnObject attrs = ['s3g', 'profile', 'gcodeparser'] for a in attrs: setattr(return_object, a, None) if len(matches) > 0: bestProfile = matches[0] setattr(return_object, 's3g', s3gBot) setattr(return_object, 'profile', makerbot_driver.Profile(bestProfile, self.profile_dir)) parser = makerbot_driver.Gcode.GcodeParser() parser.s3g = s3gBot parser.state.profile = getattr(return_object, 'profile') setattr(return_object, 'gcodeparser', parser) return return_object
def build_from_port(self, portname, leaveOpen=True, condition=None): """ Returns a tuple of an (s3gObj, ProfileObj) for a machine at port portname """ machineInquisitor = self.create_inquisitor(portname) if None is condition: condition = threading.Condition() s3gBot, machine_setup_dict = machineInquisitor.query(condition, leaveOpen) profile_regex = self.get_profile_regex(machine_setup_dict) matches = makerbot_driver.search_profiles_with_regex( profile_regex, self.profile_dir) matches = list(matches) return_object = ReturnObject() attrs = ['s3g', 'profile', 'gcodeparser'] for a in attrs: setattr(return_object, a, None) if len(matches) > 0: bestProfile = matches[0] setattr(return_object, 's3g', s3gBot) profile = makerbot_driver.Profile(bestProfile, self.profile_dir) profile.values['print_to_file_type']=[machine_setup_dict['print_to_file_type']] profile.values['software_variant'] = machine_setup_dict['software_variant'] profile.values['tool_count_error'] = machine_setup_dict['tool_count_error'] setattr(return_object, 'profile', profile) parser = makerbot_driver.Gcode.GcodeParser() parser.s3g = s3gBot parser.state.profile = getattr(return_object, 'profile') setattr(return_object, 'gcodeparser', parser) return return_object
def setUp(self): self.mock = mock.Mock(makerbot_driver.s3g()) self.g = makerbot_driver.Gcode.GcodeParser() self.g.s3g = self.mock profile = makerbot_driver.Profile("ReplicatorDual") self.g.state.profile = profile
def test_build_from_port_version_number_500_tool_count_1_Replicator(self): #Time to mock all of s3g's version! version = 500 tool_count = 1 vid, pid = 0x23C1, 0xD314 verified_status = True proper_name = 'test_bot' self.s3g_mock.get_version = mock.Mock(return_value=version) self.s3g_mock.get_toolhead_count = mock.Mock(return_value=tool_count) self.s3g_mock.get_verified_status = mock.Mock( return_value=verified_status) self.s3g_mock.get_name = mock.Mock(return_value=proper_name) self.s3g_mock.get_vid_pid = mock.Mock() self.s3g_mock.get_vid_pid.return_value = vid, pid #Mock the returned s3g obj expected_mock_s3g_obj = 'SUCCESS%i' % (version) self.factory.create_s3g = mock.Mock() self.factory.create_s3g.return_value = expected_mock_s3g_obj expected_profile = makerbot_driver.Profile('ReplicatorSingle') expected_parser = makerbot_driver.Gcode.GcodeParser() return_obj = self.factory.build_from_port('/dev/dummy_port') self.assertTrue(getattr(return_obj, 's3g') != None) self.s3g_mock.set_firmware_version.assert_called_once_with(version) self.assertEqual(expected_profile.values, getattr(return_obj, 'profile').values) self.assertTrue(getattr(return_obj, 'gcodeparser') != None)
def test_build_from_port_s3g_version(self): #Time to mock all of s3g's version! tool_count = 2 vid, pid = 0x23C1, 0xB404 advanced_version_info = { 'Version': 500, 'InternalVersion': 0, 'SoftwareVariant': 0, 'ReservedA': 0, 'ReservedB': 0, } self.s3g_mock.get_toolhead_count = mock.Mock(return_value=tool_count) self.s3g_mock.get_vid_pid = mock.Mock() self.s3g_mock.get_vid_pid.return_value = vid, pid self.s3g_mock.get_advanced_version = mock.Mock() self.s3g_mock.get_advanced_version.return_value = advanced_version_info #Mock the returned s3g obj expected_mock_s3g_obj = 'SUCCESS500' self.factory.create_s3g = mock.Mock() self.factory.create_s3g.return_value = expected_mock_s3g_obj expected_profile = makerbot_driver.Profile('ReplicatorDual') expected_profile.values['print_to_file_type'] = ['s3g'] return_obj = self.factory.build_from_port('/dev/dummy_port') self.assertTrue(getattr(return_obj, 's3g') is not None) self.s3g_mock.set_print_to_file_type.assert_called_once_with('s3g') self.assertEqual(expected_profile.values, getattr(return_obj, 'profile').values) self.assertTrue(getattr(return_obj, 'gcodeparser') is not None)
def test_profile_access(self): """ Make sure we have no issues accessing the information in the machine profile """ expected_name = "The Replicator Dual" name = "ReplicatorDual" p = makerbot_driver.Profile(name) self.assertEqual(p.values['type'], expected_name)
def create_parser(machine_name, legacy=False): parser = makerbot_driver.Gcode.GcodeParser() if legacy: parser.state = makerbot_driver.Gcode.LegacyGcodeStates() else: parser.state = makerbot_driver.Gcode.GcodeStates() parser.state.profile = makerbot_driver.Profile(machine_name) return parser
def setUp(self): self.mock = mock.Mock(makerbot_driver.s3g()) self.g = makerbot_driver.Gcode.GcodeParser() self.g.s3g = self.mock profile = makerbot_driver.Profile("ReplicatorDual") self.g.state.profile = profile for axis in ['X', 'Y', 'Z', 'A', 'B']: setattr(self.g.state.position, axis, 0) self.initial_position = [0, 0, 0, 0, 0]
def setUp(self): self.p = makerbot_driver.Gcode.GcodeParser() self.p.state = makerbot_driver.Gcode.LegacyGcodeStates() self.p.state.values['build_name'] = 'test' self.p.state.profile = makerbot_driver.Profile('TOMStepstruderSingle') self.s3g = makerbot_driver.s3g() with tempfile.NamedTemporaryFile(suffix='.gcode', delete=True) as f: path = f.name self.s3g.writer = makerbot_driver.Writer.FileWriter(open(path, 'wb')) self.p.s3g = self.s3g
def test_Profile_profiledir(self): profiledir = tempfile.mkdtemp() try: path = os.path.join(profiledir, 'Test.json') with open(path, 'w') as fp: values = {'key': 'value'} json.dump(values, fp) profile = makerbot_driver.Profile('Test', profiledir) self.assertEqual(values, profile.values) finally: shutil.rmtree(profiledir)
def test_good_profile_name(self): name = "ReplicatorSingle" p = makerbot_driver.Profile(name) path = os.path.join( os.path.abspath(os.path.dirname(__file__)), '..', 'makerbot_driver', 'profiles', name + '.json', ) with open(path) as f: expected_vals = json.load(f) self.assertEqual(expected_vals, p.values)
def setUp(self): self.p = makerbot_driver.Gcode.GcodeParser() self.s = makerbot_driver.Gcode.GcodeStates() self.s.values['build_name'] = 'test' self.profile = makerbot_driver.Profile('ReplicatorSingle') self.s.profile = self.profile self.p.state = self.s self.s3g = makerbot_driver.s3g() with tempfile.NamedTemporaryFile(suffix='.gcode', delete=False) as input_file: pass input_path = input_file.name os.unlink(input_path) self.writer = makerbot_driver.Writer.FileWriter(open(input_path, 'wb')) self.s3g.writer = self.writer self.p.s3g = self.s3g
def __init__(self, machine_profile, profiledir=None): self.machine_profile = machine_profile self.start_order = [ 'begin_print', 'homing', 'start_position', 'heat_platform', 'heat_tools', 'anchor', ] self.end_order = [ 'end_position', 'cool_platform', 'cool_tools', 'end_print', ] self.recipes = makerbot_driver.Profile('recipes', profiledir)
def setUp(self): self.p = makerbot_driver.Gcode.GcodeParser() self.p.state = makerbot_driver.Gcode.LegacyGcodeStates() self.p.state.values['build_name'] = 'test' self.p.state.profile = makerbot_driver.Profile('TOMStepstruderSingle') start_pos = self.p.state.profile.values['print_start_sequence']['start_position'] start_position = { 'START_X' : start_pos['start_x'], 'START_Y' : start_pos['start_y'], 'START_Z' : start_pos['start_z'] } self.p.environment.update(start_position) self.s3g = makerbot_driver.s3g() with tempfile.NamedTemporaryFile(suffix='.gcode', delete=True) as f: path = f.name condition = threading.Condition() self.s3g.writer = makerbot_driver.Writer.FileWriter(open(path, 'wb'), condition) self.p.s3g = self.s3g
def test_build_from_port_tool_count_2_mightyboard(self): #Time to mock all of s3g's version! tool_count = 2 vid, pid = 0x23C1, 0xB404 self.s3g_mock.get_toolhead_count = mock.Mock(return_value=tool_count) self.s3g_mock.get_vid_pid = mock.Mock() self.s3g_mock.get_vid_pid.return_value = vid, pid self.s3g_mock.get_advanced_version = mock.Mock( side_effect=makerbot_driver.CommandNotSupportedError) #Mock the returned s3g obj expected_mock_s3g_obj = 'SUCCESS500' self.factory.create_s3g = mock.Mock() self.factory.create_s3g.return_value = expected_mock_s3g_obj expected_profile = makerbot_driver.Profile('ReplicatorDual') expected_profile.values['print_to_file_type'] = ['s3g'] return_obj = self.factory.build_from_port('/dev/dummy_port') self.assertTrue(getattr(return_obj, 's3g') is not None) self.assertEqual(expected_profile.values, getattr(return_obj, 'profile').values) self.assertTrue(getattr(return_obj, 'gcodeparser') is not None)
def build_from_port(self, portname, leaveOpen=True): """ Returns a tuple of an (s3gObj, ProfileObj) for a bot at port portname """ botInquisitor = self.create_inquisitor(portname) s3gBot, bot_setup_dict = botInquisitor.query(leaveOpen) profile_regex = self.get_profile_regex(bot_setup_dict) matches = makerbot_driver.search_profiles_with_regex( profile_regex, self.profile_dir) matches = list(matches) if len(matches) > 0: bestProfile = matches[0] machine_info = (s3gBot, makerbot_driver.Profile(bestProfile, self.profile_dir)) else: machine_info = (None, None) return machine_info
def _getprinters(self): result = [] profiledir = self._config['common']['profiledir'] profile_names = list(makerbot_driver.list_profiles(profiledir)) for profile_name in profile_names: if 'recipes' != profile_name: profile = makerbot_driver.Profile(profile_name, profiledir) printer = conveyor.domain.Printer.fromprofile( profile, profile_name, None) printer.can_print = False dct = printer.todict() result.append(dct) printerthreads = self._server.getprinterthreads() for portname, printerthread in printerthreads.items(): profile = printerthread.getprofile() printerid = printerthread.getprinterid() printer = conveyor.domain.Printer.fromprofile( profile, printerid, None) dct = printer.todict() result.append(dct) return result
def connect(self, port, machineName): self.port = serial.Serial(port, 115200, timeout=1) self.driver.writer = makerbot_driver.Writer.StreamWriter(self.port, self.condition) self.connected = True self.driver.init() self.driver.display_message(0, 0, "********************", 3, False, False, False) self.driver.display_message(0, 0, " Welcome to ", 3, True, False, False) self.driver.display_message(0, 0, " MakerBotCNC! ", 3, True, False, False) self.driver.display_message(0, 0, "********************", 3, True, True, False) #self.driver.queue_song(6) if machineName in self.profileNames: self.profile = makerbot_driver.Profile(self.profileNames[machineName]) self.spm = { 'x' : self.profile.values['axes']['X']['steps_per_mm'], 'y' : self.profile.values['axes']['Y']['steps_per_mm'], 'z' : self.profile.values['axes']['Z']['steps_per_mm'] } self.origin = { 'x' : -190, 'y' : -43, 'z' : 100 } self.position = { 'x' : 0, 'y' : 0, 'z' : 0 } self.amplitude = { 'x' : 0, 'y' : 0, 'z' : 0 } for axis in self.origin.keys(): self.amplitude[axis] = abs(self.origin[axis]) else: raise Exception("Unknown Machine " + machineName) self.machinePort = port self.machineName = machineName print("Connected to machine " + machineName + " on port " + port)
def test_build_from_port_version_number_500_tool_count_2_mightyboard(self): #Time to mock all of s3g's version! version = 500 tool_count = 2 vid, pid = 0x23C1, 0xB404 verified_status = True proper_name = 'test_bot' self.s3g_mock.get_version = mock.Mock(return_value=version) self.s3g_mock.get_toolhead_count = mock.Mock(return_value=tool_count) self.s3g_mock.get_verified_status = mock.Mock( return_value=verified_status) self.s3g_mock.get_name = mock.Mock(return_value=proper_name) self.s3g_mock.get_vid_pid = mock.Mock() self.s3g_mock.get_vid_pid.return_value = vid, pid #Mock the returned s3g obj expected_mock_s3g_obj = 'SUCCESS%i' % (version) self.factory.create_s3g = mock.Mock() self.factory.create_s3g.return_value = expected_mock_s3g_obj expected_profile = makerbot_driver.Profile('ReplicatorDual') s3g_obj, profile = self.factory.build_from_port('/dev/dummy_port') self.assertTrue(s3g_obj != None) self.assertEqual(expected_profile.values, profile.values)
def setUp(self): self.p = makerbot_driver.Gcode.GcodeParser() self.s = makerbot_driver.Gcode.GcodeStates() self.s.values['build_name'] = 'test' self.profile = makerbot_driver.Profile('ReplicatorSingle') start_pos = self.profile.values['print_start_sequence']['start_position'] start_position = { 'START_X' : start_pos['start_x'], 'START_Y' : start_pos['start_y'], 'START_Z' : start_pos['start_z'] } self.p.environment.update(start_position) self.s.profile = self.profile self.p.state = self.s self.s3g = makerbot_driver.s3g() with tempfile.NamedTemporaryFile(suffix='.gcode', delete=False) as input_file: pass input_path = input_file.name os.unlink(input_path) condition = threading.Condition() self.writer = makerbot_driver.Writer.FileWriter(open(input_path, 'wb'), condition) self.s3g.writer = self.writer self.p.s3g = self.s3g
def test_build_from_port_invalid_tool_count(self): # result here is a replicator Dual - this is the default for valid replicator vid pid # we don't want a situation where the eeprom is corrupt and the bot cannot be recognized tool_count = -1 vid, pid = 0x23C1, 0xD314 self.s3g_mock.get_vid_pid = mock.Mock() self.s3g_mock.get_vid_pid.return_value = vid, pid self.s3g_mock.get_version = mock.Mock(return_value=500) self.s3g_mock.get_toolhead_count = mock.Mock(return_value=tool_count) self.s3g_mock.get_advanced_version = mock.Mock( side_effect=makerbot_driver.CommandNotSupportedError) expected_mock_s3g_obj = 'SUCCESS500' self.factory.create_s3g = mock.Mock() self.factory.create_s3g.return_value = expected_mock_s3g_obj expected_profile = makerbot_driver.Profile('ReplicatorSingle') expected_profile.values['print_to_file_type'] = ['s3g'] expected_profile.values['software_variant'] = '0x00' expected_profile.values['tool_count_error'] = True expected_parser = makerbot_driver.Gcode.GcodeParser() return_obj = self.factory.build_from_port('/dev/dummy_port') self.assertTrue(getattr(return_obj, 's3g') is not None) self.assertEqual(expected_profile.values, getattr(return_obj, 'profile').values) self.assertTrue(getattr(return_obj, 'gcodeparser') is not None)
def test_build_from_port_tool_count_1_Replicator(self): #Time to mock all of s3g's version! tool_count = 1 vid, pid = 0x23C1, 0xD314 self.s3g_mock.get_version = mock.Mock(return_value=500) self.s3g_mock.get_toolhead_count = mock.Mock(return_value=tool_count) self.s3g_mock.get_vid_pid = mock.Mock() self.s3g_mock.get_vid_pid.return_value = vid, pid self.s3g_mock.get_advanced_version = mock.Mock( side_effect=makerbot_driver.CommandNotSupportedError) #Mock the returned s3g obj expected_mock_s3g_obj = 'SUCCESS500' self.factory.create_s3g = mock.Mock() self.factory.create_s3g.return_value = expected_mock_s3g_obj expected_profile = makerbot_driver.Profile('ReplicatorSingle') expected_profile.values['print_to_file_type'] = ['s3g'] expected_profile.values['software_variant'] = '0x00' expected_profile.values['tool_count_error'] = False expected_parser = makerbot_driver.Gcode.GcodeParser() return_obj = self.factory.build_from_port('/dev/dummy_port') self.assertTrue(getattr(return_obj, 's3g') is not None) self.assertEqual(expected_profile.values, getattr(return_obj, 'profile').values) self.assertTrue(getattr(return_obj, 'gcodeparser') is not None)
def setUp(self): self.profile = makerbot_driver.Profile('ReplicatorSingle') self.g = makerbot_driver.Gcode.GcodeStates() self.g.profile = self.profile
def setUp(self): self.profile = makerbot_driver.Profile("ReplicatorDual") self.g = makerbot_driver.Gcode.GcodeStates() self.g.profile = self.profile
dest="sequences", help="Flag to not use makerbot_driver's start/end sequences", default=True, action="store_false") (options, args) = parser.parse_args() for input_file in args: validGcode = True fh = tempfile.NamedTemporaryFile() s = makerbot_driver.s3g() condition = threading.Condition() s.writer = makerbot_driver.Writer.FileWriter(fh, condition) profile = makerbot_driver.Profile(options.machine) filename = os.path.basename(input_file) filename = os.path.splitext(filename)[0] parser = makerbot_driver.Gcode.GcodeParser() parser.state.values["build_name"] = filename parser.state.profile = profile parser.s3g = s ga = makerbot_driver.GcodeAssembler(profile) start, end, variables = ga.assemble_recipe() start_gcode = ga.assemble_start_sequence(start) end_gcode = ga.assemble_end_sequence(end) parser.environment.update(variables)
def setUp(self): self.profile = makerbot_driver.Profile('ReplicatorDual') self.ga = makerbot_driver.GcodeAssembler(self.profile) self.recipes = makerbot_driver.Profile('recipes')
def setUp(self): self.g = makerbot_driver.Gcode.GcodeStates() profile = makerbot_driver.Profile('ReplicatorDual') self.g.profile = profile
def _findprofile(self, name): if None is name: name = self._config['common']['profile'] profile = makerbot_driver.Profile(name, self._config['common']['profiledir']) return profile
def test_bad_profile_name(self): bad_name = 'this_is_going_to_fail :(' with self.assertRaises(IOError): makerbot_driver.Profile(bad_name)