def test_process_should_adjust_laser_power(self):
self.laser_control = LaserControl(0.5)
self.laser_control.set_laser_on()
sample_data_chunk = numpy.array([(0, 0)])
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.process(sample_data_chunk)
self.mock_comm.send.assert_called_with(MoveMessage(0, 0, 127))
def print_layers(self,
layer_generator,
print_sub_layers=True,
dry_run=False,
force_source_speed=False):
logger.info("Shuffled: %s" %
self._configuration.options.use_shufflelayers)
logger.info("Sublayered: %s" %
self._configuration.options.use_sublayers)
logger.info("Overlapped: %s" % self._configuration.options.use_overlap)
if self._configuration.options.use_sublayers and print_sub_layers:
layer_generator = SubLayerGenerator(
layer_generator,
self._configuration.options.sublayer_height_mm)
if self._configuration.options.use_shufflelayers:
layer_generator = ShuffleGenerator(
layer_generator,
self._configuration.options.shuffle_layers_amount)
if self._configuration.options.use_overlap:
layer_generator = OverLapGenerator(
layer_generator, self._configuration.options.overlap_amount)
if self._configuration.serial.on:
self._commander = SerialCommander(self._configuration.serial.port)
else:
self._commander = NullCommander()
self.laser_control = LaserControl(
self._configuration.cure_rate.override_laser_power_amount)
transformer = HomogenousTransformer(
self._configuration.calibration.max_deflection,
self._configuration.calibration.height,
self._configuration.calibration.lower_points,
self._configuration.calibration.upper_points,
)
state = MachineState()
self._status = MachineStatus()
if dry_run:
abort_on_error = False
else:
abort_on_error = True
self._zaxis = self._get_zaxis(dry_run)
disseminator = self._get_digital_disseminator(dry_run)
path_to_points = PathToPoints(
disseminator.samples_per_second, transformer,
self._configuration.options.laser_thickness_mm)
if force_source_speed:
override_draw_speed = None
override_move_speed = None
else:
override_draw_speed = self._configuration.cure_rate.draw_speed if self._configuration.cure_rate.use_draw_speed else None
override_move_speed = self._configuration.cure_rate.move_speed if self._configuration.cure_rate.use_draw_speed else None
pre_layer_delay = self._configuration.options.pre_layer_delay if self._configuration.options.pre_layer_delay else 0.0
post_fire_delay_speed = None
slew_delay_speed = None
if self._configuration.options.post_fire_delay:
post_fire_delay_speed = self._configuration.options.laser_thickness_mm / (
float(self._configuration.options.post_fire_delay) / 1000.0)
if self._configuration.options.slew_delay:
slew_delay_speed = self._configuration.options.laser_thickness_mm / (
float(self._configuration.options.slew_delay) / 1000.0)
if self._configuration.options.wait_after_move_milliseconds > 0:
wait_speed = self._configuration.options.laser_thickness_mm / (
float(self._configuration.options.wait_after_move_milliseconds)
/ 1000.0)
else:
wait_speed = None
self._writer = LayerWriter(disseminator,
path_to_points,
self.laser_control,
state,
move_distance_to_ignore=self._configuration.
options.laser_thickness_mm,
override_draw_speed=override_draw_speed,
override_move_speed=override_move_speed,
wait_speed=wait_speed,
post_fire_delay_speed=post_fire_delay_speed,
slew_delay_speed=slew_delay_speed)
self._layer_processing = LayerProcessing(
self._writer,
state,
self._status,
self._zaxis,
self._configuration.dripper.max_lead_distance_mm,
self._commander,
pre_layer_delay,
self._configuration.serial.layer_started,
self._configuration.serial.layer_ended,
self._configuration.serial.print_ended,
self._configuration.serial.on_command,
self._configuration.serial.off_command,
)
if self._zaxis:
self._zaxis.set_call_back(self._status.drip_call_back)
self._zaxis.start()
self._controller = Controller(
self._writer,
self._layer_processing,
layer_generator,
self._status,
abort_on_error=abort_on_error,
)
self._controller.start()
def test_laser_power_throws_if_outside_range(self):
with self.assertRaises(Exception):
LaserControl(1.001)
with self.assertRaises(Exception):
LaserControl(-0.001)
def test_laser_power_shows_default_when_provided(self):
expected_laser_power = 0.6
l = LaserControl(expected_laser_power)
l.set_laser_on()
self.assertEquals(expected_laser_power, l.laser_power())
def test_laser_power_shows_1_when_laser_on(self):
l = LaserControl()
l.set_laser_on()
self.assertEquals(1.0, l.laser_power())
def test_laser_power_shows_0_when_laser_off(self):
l = LaserControl()
l.set_laser_off()
self.assertEquals(0.0, l.laser_power())
def test_turn_laser_off_shows_laser_off(self):
l = LaserControl()
l.set_laser_on()
self.assertTrue(l.laser_is_on())
l.set_laser_off()
self.assertFalse(l.laser_is_on())
def test_default_state_is_off(self):
l = LaserControl()
self.assertFalse(l.laser_is_on())
def __init__(self, configuration_manager):
logger.info("Calibartion API Startup")
self._configuration_manager = configuration_manager
self._configuration = self._configuration_manager.load()
self._point_generator = SinglePointGenerator()
self._blink_generator = BlinkGenerator()
self._orientaiton_generator = OrientationGenerator()
self._alignment_generator = CalibrationLineGenerator()
self._scale_generator = ScaleGenerator(speed=2.0, radius=1.0)
self._test_patterns = {
'Hilbert Space Filling Curve': HilbertGenerator(),
'Square': SquareGenerator(),
'Circle': CircleGenerator(),
'Spiral': SpiralGenerator(),
'Memory Hourglass': MemoryHourglassGenerator(),
'Damping Test': DampingTestGenerator(),
'NESW': NESWGenerator(),
'Twitch': TwitchGenerator(),
}
self._current_generator = self._point_generator
self._laser_control = LaserControl(self._configuration.cure_rate.override_laser_power_amount)
transformer = TuningTransformer(scale=self._configuration.calibration.max_deflection)
self._controller = None
logger.debug("Setting up audiowriter")
self._current_generator = self._point_generator
self._state = MachineState()
self._status = MachineStatus()
self._communicator = UsbPacketCommunicator(self._configuration.circut.calibration_queue_length)
self._communicator.start()
self._disseminator = MicroDisseminator(
self._laser_control,
self._communicator,
self._configuration.circut.data_rate
)
self._path_to_points = PathToPoints(
self._disseminator.samples_per_second,
transformer,
self._configuration.options.laser_thickness_mm
)
post_fire_delay_speed = None
slew_delay_speed = None
if self._configuration.options.post_fire_delay:
post_fire_delay_speed = self._configuration.options.laser_thickness_mm / (float(self._configuration.options.post_fire_delay) / 1000.0)
if self._configuration.options.slew_delay:
slew_delay_speed = self._configuration.options.laser_thickness_mm / (float(self._configuration.options.slew_delay) / 1000.0)
self._writer = LayerWriter(
self._disseminator,
self._path_to_points,
self._laser_control,
self._state,
post_fire_delay_speed=post_fire_delay_speed,
slew_delay_speed=slew_delay_speed
)
self._layer_processing = LayerProcessing(
self._writer,
self._state,
self._status,
)
self._controller = Controller(
self._writer,
self._layer_processing,
self._current_generator,
self._status,
abort_on_error=False,
)
self.make_pattern_fit()
self._controller.start()
def test_next_layer_does_nothing(self):
micro_disseminator = MicroDisseminator(LaserControl(), MagicMock(), 8000)
micro_disseminator.next_layer(7.7)
def test_samples_per_second_is_data_rate(self):
expected_samples_per_second = 8000
micro_disseminator = MicroDisseminator(LaserControl(), MagicMock(), expected_samples_per_second)
self.assertEquals(expected_samples_per_second, micro_disseminator.samples_per_second)
def setUp(self):
self.max_value = pow(2, MicroDisseminator.BIT_DEPTH) - 1
self.mock_comm = MagicMock()
self.laser_control = LaserControl()
class MicroDisseminatorTests(unittest.TestCase, TestHelpers):
def setUp(self):
self.max_value = pow(2, MicroDisseminator.BIT_DEPTH) - 1
self.mock_comm = MagicMock()
self.laser_control = LaserControl()
def test_samples_per_second_is_data_rate(self):
expected_samples_per_second = 8000
micro_disseminator = MicroDisseminator(LaserControl(), MagicMock(), expected_samples_per_second)
self.assertEquals(expected_samples_per_second, micro_disseminator.samples_per_second)
def test_next_layer_does_nothing(self):
micro_disseminator = MicroDisseminator(LaserControl(), MagicMock(), 8000)
micro_disseminator.next_layer(7.7)
def test_process_should_call_com_with_move_when_laser_off(self):
self.laser_control.set_laser_off()
sample_data_chunk = numpy.array([(0, 0)])
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.process(sample_data_chunk)
self.mock_comm.send.assert_called_with(MoveMessage(0, 0, 0))
def test_process_should_call_com_with_move_when_laser_on(self):
self.laser_control.set_laser_on()
sample_data_chunk = numpy.array([(0, 0)])
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.process(sample_data_chunk)
self.mock_comm.send.assert_called_with(MoveMessage(0, 0, 255))
def test_process_should_adjust_laser_power(self):
self.laser_control = LaserControl(0.5)
self.laser_control.set_laser_on()
sample_data_chunk = numpy.array([(0, 0)])
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.process(sample_data_chunk)
self.mock_comm.send.assert_called_with(MoveMessage(0, 0, 127))
def test_process_should_call_com_with_correct_posisitions(self):
self.laser_control.set_laser_on()
sample_data_chunk = numpy.array([(1, 1)])
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.process(sample_data_chunk)
self.mock_comm.send.assert_called_with(MoveMessage(self.max_value, self.max_value, 255))
def test_process_should_handle_empty_lists(self):
self.laser_control.set_laser_on()
sample_data_chunk = numpy.array([])
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.process(sample_data_chunk)
self.assertEqual(0, self.mock_comm.send.call_count)
def test_process_should_call_com_each_element_in_list(self):
self.laser_control.set_laser_on()
sample_data_chunk = numpy.array([(0.0, 1.0), (0.5, 0.0), (1.0, 0.5)])
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.process(sample_data_chunk)
self.mock_comm.send.assert_has_calls([
call(MoveMessage(0, self.max_value, 255)),
call(MoveMessage(self.max_value / 2, 0, 255)),
call(MoveMessage(self.max_value, self.max_value / 2, 255)),
])
def test_close_calls_close_on_communicator(self):
micro_disseminator = MicroDisseminator(self.laser_control, self.mock_comm, 8000)
micro_disseminator.close()
self.mock_comm.close.assert_called_with()
