Esempio n. 1
0
    def _mix_water_to_temperature(self, target_temperature):
        sample = copy.deepcopy(self._waste_water_point)
        sample.f = 5000
        const_time = 1
        const_water = CONST_ML * const_time

        # z first than x, y
        stepper = self._runner.step([
            [
                Point.create_point(z=sample.z, f=sample.f),
                Point.create_point(z=sample.z, f=sample.f)
            ],
            [
                Point.create_point(x=sample.x, y=sample.y, f=sample.f),
                Point.create_point(x=sample.x, y=sample.y, f=sample.f)
            ]
        ])
        stepper.next()
        stepper.next()

        count = 0
        while(target_temperature + 2 < self._output_temp_reader.read() or
                target_temperature - 2 > self._output_temp_reader.read()):

            if count > 14:
                break

            points = []
            for index in range(0, const_water * 5, 2):
                points.append(Point.create_point(t=target_temperature, e=0.2, f=100))

            # Let _mix to create the hot/cold points accroding to the temperature.
            pair_points = self._mixer._mix(points)
            stepper = self._runner.step(pair_points)

            while self._stop_flag is not True:
                try:
                    stepper.next()
                except StopIteration:
                    break

            count += 1

        return True
Esempio n. 2
0
    def _calibration(self):

        waste_water_point = copy.deepcopy(self._waste_water_point)
        waste_water_point.f = 5000

        # HOME
        stepper = self._runner.step([
            [
                Point.create_command('home'),
                Point.create_command('home')
            ],
            [
                Point.create_point(z=waste_water_point.z, f=waste_water_point.f),
                Point.create_point(z=waste_water_point.z, f=waste_water_point.f)
            ],
            [
                waste_water_point,
                waste_water_point
            ]
        ])
        stepper.next()
        stepper.next()
        stepper.next()

        # Output Cold water
        stepper = self._runner.step([
            [
                Point.create_point(f=180),
                Point.create_point(e=0.1, f=180)
            ]
        ] * 1000)
        while self._stop_flag is not True:
            try:
                stepper.next()
            except StopIteration:
                break
        if self._stop_flag is True:
            return

        self._mixer.capture_calibration_cold()

        # Output Hot water
        stepper = self._runner.step([
            [
                Point.create_point(e=0.1, f=180),
                Point.create_point(f=180)
                ]
            ] * 1000)
        while self._stop_flag is not True:
            try:
                stepper.next()
            except StopIteration:
                break
        if self._stop_flag is True:
            return

        self._mixer.capture_calibration_hot()
        return True
Esempio n. 3
0
def test_create_point():
    p = Point.create_point()
    assert p.is_point() is True