Added sinwave strategy for wet test

Should range from [-4, 4] in x and travel forward 16pi meters. That should be plenty to see if its working

Author: haydenshively

TESTING.py

@@ -0,0 +1,50 @@
+class Visualizer(object):
+    def __init__(self):
+        import cv2
+        self.cv2 = cv2
+        from numpy import zeros
+
+        self.counter = 0
+        self.position_graph = zeros((800, 800, 3), dtype = 'uint8')
+
+    def position(self, x, y, z, every = 100):
+        if self.counter%every is 0:
+            blue = 255 + 50*z# color represents depth
+            self.cv2.circle(self.position_graph, (int(10*x) + 400, 800 - int(10*y)), 5, (blue, 255, 0), -1)
+            self.cv2.imshow('position', self.position_graph)
+            self.cv2.waitKey(1)
+
+        self.counter += 1
+
+def main(simulating = False):
+    if simulating:
+        from main_module.gyro.simulation import Simulated as Gyro
+        from main_module.odometer.simulation import Simulated as Odometer
+        from main_module.propulsion.simulation import Simulated as Propulsion
+        from main_module.planning.s2018 import coach
+
+        gyro = Gyro(30.0)
+        odometer = Odometer(30.0)
+        propulsion = Propulsion(gyro, 30.0)
+
+        strategy = coach.list_of_strategies()[2]
+        strategy = coach.initialize(strategy, gyro, odometer)
+
+        visualizer = Visualizer()
+
+        while True:
+            try:
+                strategy.run(propulsion, [])
+                # print(odometer.position.xyz)
+                visualizer.position(odometer.position.x, odometer.position.y, odometer.position.z)
+            except KeyboardInterrupt:
+                break
+
+    else:
+        from main_module.gyro.ros_gyro import ROS_Gyro as Gyro
+        from main_module.odometer.ros_odometer import ROS_Odometer as Odometer
+        from main_module.propulsion.robot2018 import Robot2018 as Propulsion
+
+
+if __name__ == '__main__':
+    main(simulating = True)

main_module/paths/curve.py

@@ -26,7 +26,7 @@ def independent_variable(self):
 
 usage example:
 my_func = lambda t: [t, t**2, t**3]
-my_curve = P_Curve(my_func, 0.0, 3.0)
+my_curve = Curve(my_func, 0.0, 3.0)
 
 while my_curve.increment(0.5):
     print(my_curve.target)

main_module/planning/s2018/coach.py

@@ -1,9 +1,9 @@
 from ..strategy import Strategy as AbstractStrategy
-from .test import TestA, TestB
+from .test import TestA, TestB, SinWave
 
 def list_of_strategies(also_return_names = False):
-    if also_return_names: return ((TestA, TestA.name), (TestB, TestB.name))
-    else: return (TestA, TestB)
+    if also_return_names: return ((TestA, TestA.name), (TestB, TestB.name), (SinWave, SinWave.name))
+    else: return (TestA, TestB, SinWave)
 
 def initialize(Strategy, gyro, odometer):# TODO use this issubclass pattern everywhere
     if issubclass(Strategy, AbstractStrategy): return Strategy(gyro, odometer)

main_module/planning/s2018/test.py

@@ -2,7 +2,7 @@
 sys.path.append('..')
 
 from main_module.paths.cubic_spline import CubicSpline
-from main_module.planning.strategy import *
+from ..strategy import *
 class TestA(Strategy):
 
     name = 'Skewed Figure-Eight'
@@ -87,3 +87,32 @@ def _say_goodbye(propulsion, subsystems, call_count):
             print('Running Event:')
             print('Goodbye!')
             print('')
+
+from math import sin
+from main_module.paths.curve import Curve
+class SinWave(Strategy):
+
+    name = 'sin wave'
+
+    def __init__(self, gyro, odometer):
+        import sys
+        version = sys.version_info[0]
+        if version == 2: super(SinWave, self).__init__(gyro, odometer)# Python 2
+        else: super().__init__(gyro, odometer)# Python 3
+        del sys
+        """
+        use this space to set instance variables that
+        get_leash or get_events may depend on
+
+        also use this space to set odometer origin
+        """
+        # now ready to init
+        self.init()
+
+    def _get_leash(self):
+        my_lambda = lambda t: [4.0*sin(t), 2.0*t, -3]
+        path0 = Curve(my_lambda, 0.0, 8*3.1415)
+        return Leash([path0], 0.75, 0.01)
+
+    def _get_events(self):
+        return Events([], [])