コード例 #1
0
    def test_should_return_led(self):
        expected_led = Pin(21)
        led = Pin(21)

        arm = Arm_partial(None, None, None, None, None, led)

        current_led = arm.get_motor("l")

        self.assertEquals(expected_led.value, current_led.value)
        self.assertEquals(expected_led.number, current_led.number)
コード例 #2
0
    def test_should_turn_off_led(self):
        executor = RPiExecutor()
        pin = Pin(21)

        pin.off = MagicMock()
        executor.go = MagicMock()

        control = Control(None, executor, pin)

        control.turn_off_led()

        pin.off.assert_called_with()
        executor.go.assert_called_with(pin)
コード例 #3
0
    def pi_arm_configuration(self):
        Configuration().configure()
        self._executor = RPiExecutor()

        waist = Motor(13, 19)
        shoulder = Motor(23, 24)
        elbow = Motor(17, 27)
        wrist = Motor(16, 20)
        gripper = Motor(5, 6)
        led = Pin(21)
        arm = Arm_partial(waist, shoulder, elbow, wrist, gripper, led)
        self._arm = arm
        self._led = led
        control = Control(None, self._executor, self._led)
        pi_arm = PiArm(control)

        return control, pi_arm
コード例 #4
0
    def __init__(self, control):
        Configuration().configure()
        self._executor = RPiExecutor()

        waist = Motor(13, 19)
        shoulder = Motor(23, 24)
        elbow = Motor(17, 27)
        wrist = Motor(16, 20)
        gripper = Motor(5, 6)
        led = Pin(21)

        arm = Arm_partial(waist, shoulder, elbow, wrist, gripper, led)
        self._arm = arm
        self._led = led

        if control == None:
            print "runtime constructor"
            self._control = Control(None, self._executor, self._led)

        else:
            print "test constructor"
            self._control = control
コード例 #5
0
    def should_be_call_parser_with_joint(self):
        Configuration().configure()
        self._executor = RPiExecutor()

        waist = Motor(13, 19)
        shoulder = Motor(23, 24)
        elbow = Motor(17, 27)
        wrist = Motor(16, 20)
        gripper = Motor(5, 6)
        led = Pin(21)
        arm = Arm_partial(waist, shoulder, elbow, wrist, gripper, led)
        self._arm = arm
        self._led = led
        control = Control(None, self._executor, self._led)
        pi_arm = PiArm(control)

        input_primitive_joints = "g c 10"
        pi_arm.execute_joint = MagicMock()
        expected_joint = Joint_partial("g", "c", 10)

        pi_arm.parse_joints(input_primitive_joints)

        pi_arm.execute_joint.assert_called_with(expected_joint)
コード例 #6
0
    def test_should_configure_arm(self):
        expected_waist = Motor(13, 19)
        expected_shoulder = Motor(23, 24)
        expected_elbow = Motor(17, 27)
        expected_wrist = Motor(16, 20)
        expected_gripper = Motor(5, 6)
        expected_led = Pin(21)

        expected_arm = Arm_partial(expected_waist, expected_shoulder, expected_elbow, expected_wrist, expected_gripper, expected_led)

        pi_arm = PiArm(None)
        current_arm = pi_arm._arm

        self.assertEquals(current_arm.waist.pin_a.number, expected_arm.waist.pin_a.number)
        self.assertEquals(current_arm.waist.pin_b.number, expected_arm.waist.pin_b.number)
        self.assertEquals(current_arm.shoulder.pin_a.number, expected_arm.shoulder.pin_a.number)
        self.assertEquals(current_arm.shoulder.pin_b.number, expected_arm.shoulder.pin_b.number)
        self.assertEquals(current_arm.elbow.pin_a.number, expected_arm.elbow.pin_a.number)
        self.assertEquals(current_arm.elbow.pin_b.number, expected_arm.elbow.pin_b.number)
        self.assertEquals(current_arm.wrist.pin_a.number, expected_arm.wrist.pin_a.number)
        self.assertEquals(current_arm.wrist.pin_b.number, expected_arm.wrist.pin_b.number)
        self.assertEquals(current_arm.gripper.pin_a.number, expected_arm.gripper.pin_a.number)
        self.assertEquals(current_arm.gripper.pin_b.number, expected_arm.gripper.pin_b.number)
        self.assertEquals(current_arm.led.number, expected_arm.led.number)
コード例 #7
0
from src.main.logic.parser import Parser
from src.main.Infra.rpiexecutor import RPiExecutor
from src.main.logic.control import Control
from src.main.domain.motor import Motor
from src.main.configuration.configuration import Configuration
from src.main.domain.arm_partial import Arm_partial

Configuration().configure()
executor = RPiExecutor()

waist = Motor(13, 19)
shoulder = Motor(23, 24)
elbow = Motor(17, 27)
wrist = Motor(16, 20)
gripper = Motor(5, 6)
led = Pin(21)

arm = Arm_partial(waist, shoulder, elbow, wrist, gripper, led)

while True:
    primitive_joints = raw_input("enter a joints <(name direction value) ... > : ")

    parser = Parser()
    joints = parser.get_joints(primitive_joints)

    for joint in joints:
        motor = arm.get_motor(joint.name)

        print "direction :" + joint.direction

        control = Control(motor, executor, led)
コード例 #8
0
 def __init__(self, pin_a, pin_b):
     self._pin_a = Pin(pin_a)
     self._pin_b = Pin(pin_b)
     self._is_on = False
コード例 #9
0
    def test_should_return_pin_led(self):
        expected_pin = 1
        pin = Pin(1)
        current_pin = pin.number

        self.assertEquals(current_pin, expected_pin)
コード例 #10
0
    def test_should_return_true_when_call_off(self):
        pin = Pin(1)
        pin.off()

        self.assertFalse(pin.value)
コード例 #11
0
    def test_should_return_true_when_call_on(self):
        pin = Pin(1)
        pin.on()

        self.assertTrue(pin.value)
コード例 #12
0
    def test_should_return_true(self):
        expected_value = False
        pin = Pin(1)
        current_value = pin.value

        self.assertEquals(current_value, expected_value)