Merge branch 'develop' of https://github.com/rhempel/ev3dev-lang-python into develop

Author: rhempel

demo/lego_official_projects/TRACK3R.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+
+import logging
+import sys
+from ev3dev.auto import OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D
+from ev3dev.helper import RemoteControlledTank, MediumMotor
+
+log = logging.getLogger(__name__)
+
+
+class TRACK3R(RemoteControlledTank):
+    """
+    Base class for all TRACK3R variations. The only difference in the child
+    classes are in how the medium motor is handled.
+
+    To enable the medium motor toggle the beacon button on the EV3 remote.
+    """
+
+    def __init__(self, medium_motor, left_motor, right_motor):
+        RemoteControlledTank.__init__(self, left_motor, right_motor)
+        self.medium_motor = MediumMotor(medium_motor)
+
+        if not self.medium_motor.connected:
+            log.error("%s is not connected" % self.medium_motor)
+            sys.exit(1)
+
+        self.medium_motor.reset()
+
+
+class TRACK3RWithBallShooter(TRACK3R):
+
+    def __init__(self, medium_motor=OUTPUT_A, left_motor=OUTPUT_B, right_motor=OUTPUT_C):
+        TRACK3R.__init__(self, medium_motor, left_motor, right_motor)
+        self.remote.on_beacon = self.fire_ball
+
+    def fire_ball(self, state):
+        if state:
+            self.medium_motor.run_to_rel_pos(duty_cycle_sp=100, position_sp=3*360)
+        else:
+            self.medium_motor.stop()
+
+
+class TRACK3RWithSpinner(TRACK3R):
+
+    def __init__(self, medium_motor=OUTPUT_A, left_motor=OUTPUT_B, right_motor=OUTPUT_C):
+        TRACK3R.__init__(self, medium_motor, left_motor, right_motor)
+        self.remote.on_beacon = self.spinner
+
+    def spinner(self, state):
+        if state:
+            self.medium_motor.run_forever(duty_cycle_sp=50)
+        else:
+            self.medium_motor.stop()
+
+
+class TRACK3RWithClaw(TRACK3R):
+
+    def __init__(self, medium_motor=OUTPUT_A, left_motor=OUTPUT_B, right_motor=OUTPUT_C):
+        TRACK3R.__init__(self, medium_motor, left_motor, right_motor)
+        self.remote.on_beacon = self.move_claw
+
+    def move_claw(self, state):
+        if state:
+            self.medium_motor.run_to_rel_pos(duty_cycle_sp=40, position_sp=-75)
+        else:
+            self.medium_motor.run_to_rel_pos(duty_cycle_sp=40, position_sp=75)

demo/lego_official_projects/TRACK3RWithBallShooter

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+
+import logging
+from TRACK3R import TRACK3RWithBallShooter
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s %(levelname)5s: %(message)s')
+log = logging.getLogger(__name__)
+
+log.info("Starting TRACK3RWithBallShooter")
+tracker = TRACK3RWithBallShooter()
+tracker.main()
+log.info("Exiting TRACK3RWithBallShooter")

demo/lego_official_projects/TRACK3RWithClaw

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+
+import logging
+from TRACK3R import TRACK3RWithClaw
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s %(levelname)5s: %(message)s')
+log = logging.getLogger(__name__)
+
+log.info("Starting TRACK3RWithClaw")
+tracker = TRACK3RWithClaw()
+tracker.main()
+log.info("Exiting TRACK3RWithClaw")

demo/lego_official_projects/TRACK3RWithSpinner

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+
+import logging
+from TRACK3R import TRACK3RWithSpinner
+
+logging.basicConfig(level=logging.DEBUG,
+                    format='%(asctime)s %(levelname)5s: %(message)s')
+log = logging.getLogger(__name__)
+
+log.info("Starting TRACK3RWithSpinner")
+tracker = TRACK3RWithSpinner()
+tracker.main()
+log.info("Exiting TRACK3RWithSpinner")

ev3dev/brickpi.py

@@ -53,6 +53,7 @@ class Leds(object):
     LED1 = ( blue_led1, )
     LED2 = ( blue_led2, )
 
+    BLACK = ( 0, )
     BLUE = ( 1, )
 
     @staticmethod

ev3dev/core.py

@@ -163,6 +163,7 @@ def __init__(self, class_name, name_pattern='*', name_exact=False, **kwargs):
 
         classpath = abspath(Device.DEVICE_ROOT_PATH + '/' + class_name)
         self._attribute_cache = FileCache()
+        self.kwargs = kwargs
 
         def get_index(file):
             match = Device._DEVICE_INDEX.match(file)
@@ -182,8 +183,16 @@ def get_index(file):
                 self._device_index = get_index(name)
                 self.connected = True
             except StopIteration:
+                self._path = None
+                self._device_index = None
                 self.connected = False
 
+    def __str__(self):
+        if 'address' in self.kwargs:
+            return "%s(%s)" % (self.__class__.__name__, self.kwargs.get('address'))
+        else:
+            return self.__class__.__name__
+
     def _matches(self, attribute, pattern):
         """Test if attribute value matches pattern (that is, if pattern is a
         substring of attribute value).  If pattern is a list, then a match with
@@ -1893,6 +1902,9 @@ class ButtonBase(object):
     Abstract button interface.
     """
 
+    def __str__(self):
+        return self.__class__.__name__
+
     @staticmethod
     def on_change(changed_buttons):
         """

ev3dev/ev3.py

@@ -55,6 +55,7 @@ class Leds(object):
     LEFT = ( red_left, green_left, )
     RIGHT = ( red_right, green_right, )
 
+    BLACK = ( 0, 0, )
     RED = ( 1, 0, )
     GREEN = ( 0, 1, )
     AMBER = ( 1, 1, )

ev3dev/helper.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python
+
+import logging
+import sys
+import time
+import ev3dev.auto
+from ev3dev.auto import (RemoteControl, list_motors,
+                         INPUT_1, INPUT_2, INPUT_3,INPUT_4,
+                         OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D)
+from math import pi
+from time import sleep
+
+log = logging.getLogger(__name__)
+
+INPUTS = (INPUT_1, INPUT_2, INPUT_3, INPUT_4)
+OUTPUTS = (OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D)
+
+def wait_for(condition, timeout=1e5, interval=0.01):
+    tic = time.time() + timeout
+    done = condition()
+
+    while time.time() < tic and not done:
+        time.sleep(interval)
+        done = condition()
+
+    return done
+
+
+# =============
+# Motor classes
+# =============
+class MotorMixin(object):
+
+    def wait_for_running(self):
+        return wait_for(lambda: 'running' in self.state, 1)
+
+    def wait_for_stop(self):
+        return wait_for(lambda: 'running' not in self.state, 1)
+
+
+class LargeMotor(ev3dev.auto.LargeMotor, MotorMixin):
+    pass
+
+
+class MediumMotor(ev3dev.auto.MediumMotor, MotorMixin):
+    pass
+
+
+# ============
+# Tank classes
+# ============
+class Tank(object):
+
+    def __init__(self, left_motor, right_motor, polarity='normal'):
+
+        for motor in (left_motor, right_motor):
+            if motor not in OUTPUTS:
+                log.error("%s in an invalid motor, choices are %s" % (motor, ', '.join(OUTPUTS)))
+                sys.exit(1)
+
+        self.left_motor = LargeMotor(left_motor)
+        self.right_motor = LargeMotor(right_motor)
+
+        for x in (self.left_motor, self.right_motor):
+            if not x.connected:
+                log.error("%s is not connected" % x)
+                sys.exit(1)
+
+        self.left_motor.reset()
+        self.right_motor.reset()
+        self.duty_cycle_sp = 90
+        self.left_motor.duty_cycle_sp = self.duty_cycle_sp
+        self.right_motor.duty_cycle_sp = self.duty_cycle_sp
+        self.set_polarity(polarity)
+
+    def set_polarity(self, polarity):
+        valid_choices = ('normal', 'inversed')
+        assert polarity in valid_choices,\
+            "%s is an invalid polarity choice, must be %s" % (polarity, ', '.join(valid_choices))
+
+        self.left_motor.polarity = polarity
+        self.right_motor.polarity = polarity
+
+
+class RemoteControlledTank(Tank):
+
+    def __init__(self, left_motor, right_motor, polarity='inversed'):
+        Tank.__init__(self, left_motor, right_motor, polarity)
+        self.remote = RemoteControl(channel=1)
+
+        if not self.remote.connected:
+            log.error("%s is not connected" % self.remote)
+            sys.exit(1)
+
+        self.remote.on_red_up = self.make_move(self.left_motor, self.duty_cycle_sp)
+        self.remote.on_red_down = self.make_move(self.left_motor, self.duty_cycle_sp * -1)
+        self.remote.on_blue_up = self.make_move(self.right_motor, self.duty_cycle_sp)
+        self.remote.on_blue_down = self.make_move(self.right_motor, self.duty_cycle_sp * -1)
+
+    def make_move(self, motor, dc_sp):
+        def move(state):
+            if state:
+                motor.run_forever(duty_cycle_sp=dc_sp)
+            else:
+                motor.stop()
+        return move
+
+    def main(self):
+
+        try:
+            while True:
+                self.remote.process()
+                time.sleep(0.01)
+
+        # Exit cleanly so that all motors are stopped
+        except (KeyboardInterrupt, Exception) as e:
+            log.exception(e)
+
+            for motor in list_motors():
+                motor.stop()
+
+
+# =====================
+# Wheel and Rim classes
+# =====================
+class Wheel(object):
+    """
+    A base class for various types of wheels, tires, etc
+    All units are in mm
+    """
+
+    def __init__(self, diameter, width):
+        self.diameter = float(diameter)
+        self.width = float(width)
+        self.radius = float(diameter/2)
+        self.circumference = diameter * pi
+
+
+# A great reference when adding new wheels is http://wheels.sariel.pl/
+class EV3RubberWheel(Wheel):
+
+    def __init__(self):
+        Wheel.__init__(self, 43.2, 21)

utils/move_motor.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+"""
+Used to adjust the position of a motor in an already assembled robot
+where you can"t move the motor by hand.
+"""
+
+from ev3dev.auto import OUTPUT_A, OUTPUT_B, OUTPUT_C, OUTPUT_D
+from ev3dev.helper import LargeMotor
+import argparse
+import logging
+import sys
+
+# command line args
+parser = argparse.ArgumentParser(description="Used to adjust the position of a motor in an already assembled robot")
+parser.add_argument("motor", type=str, help="A, B, C or D")
+parser.add_argument("degrees", type=int)
+parser.add_argument("-s", "--speed", type=int, default=50)
+args = parser.parse_args()
+
+# logging
+logging.basicConfig(level=logging.DEBUG,
+                    format="%(asctime)s %(levelname)5s: %(message)s")
+log = logging.getLogger(__name__)
+
+# For this it doesn't really matter if it is a LargeMotor or a MediumMotor
+if args.motor == "A":
+    motor = LargeMotor(OUTPUT_A)
+elif args.motor == "B":
+    motor = LargeMotor(OUTPUT_B)
+elif args.motor == "C":
+    motor = LargeMotor(OUTPUT_C)
+elif args.motor == "D":
+    motor = LargeMotor(OUTPUT_D)
+else:
+    raise Exception("%s is invalid, options are A, B, C, D")
+
+if not motor.connected:
+    log.error("%s is not connected" % motor)
+    sys.exit(1)
+
+motor.reset()
+log.info("Motor %s, move to position %d" % (args.motor, args.degrees))
+motor.run_to_rel_pos(duty_cycle_sp=args.speed, position_sp=args.degrees)
+motor.wait_for_running()
+log.info("Motor %s is running" % args.motor)
+motor.wait_for_stop()
+log.info("Motor %s stopped, final position %d" % (args.motor, motor.position))

utils/stop_all_motors.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+
+"""
+Stop all motors
+"""
+from ev3dev.auto import list_motors
+
+for motor in list_motors():
+    motor.stop()