dwm1000 kalman: Check covariance < 0
[ros_wild_thumper.git] / scripts / dwm1000.py
index d36a5d2f7e683fbc9e96e773ac874aa91821c2b9..52a9e2730bc9853bfbf80efaaa42342fcb8ff6cb 100755 (executable)
@@ -9,10 +9,12 @@ import rospy
 import tf
 import numpy as np
 from math import *
 import tf
 import numpy as np
 from math import *
+from datetime import datetime
 from i2c import i2c
 from time import sleep
 from std_msgs.msg import Float32
 from nav_msgs.msg import Odometry
 from i2c import i2c
 from time import sleep
 from std_msgs.msg import Float32
 from nav_msgs.msg import Odometry
+from wild_thumper.srv import DWM1000Center, DWM1000CenterResponse
 if VISULAIZE:
        import matplotlib.pyplot as plt
 
 if VISULAIZE:
        import matplotlib.pyplot as plt
 
@@ -40,6 +42,10 @@ class simple_kalman:
 
                return x
 
 
                return x
 
+       def set_measure_cov(self, R):
+               if R > 0:
+                       self.R = R
+
 class DW1000(threading.Thread):
        def __init__(self, name, addr, offset):
                threading.Thread.__init__(self)
 class DW1000(threading.Thread):
        def __init__(self, name, addr, offset):
                threading.Thread.__init__(self)
@@ -48,6 +54,7 @@ class DW1000(threading.Thread):
                self.offset = offset
                self.addr = addr
                self.name = name
                self.offset = offset
                self.addr = addr
                self.name = name
+               self.last_update = datetime.min
 
                self.pub = rospy.Publisher(name, Float32, queue_size=16)
 
 
                self.pub = rospy.Publisher(name, Float32, queue_size=16)
 
@@ -62,14 +69,21 @@ class DW1000(threading.Thread):
        def distance(self):
                return self.dist
 
        def distance(self):
                return self.dist
 
+       # Returns each distance only if current
+       def distance_valid(self):
+               if (datetime.now() - self.last_update).seconds < 1:
+                       return self.dist
+               return None
+
        def run(self):
                last_val = 10
        def run(self):
                last_val = 10
-               while True:
+               while not rospy.is_shutdown():
                        val = self.get_value()
                        if abs(val - last_val)  > 10:
                        val = self.get_value()
                        if abs(val - last_val)  > 10:
-                               print "Ignoring values too far apart %s: %.2f - %.2f" % (self.name, val, last_val)
+                               rospy.logwarn("Ignoring values too far apart %s: %.2f - %.2f", self.name, val, last_val)
                        elif not isnan(val):
                                self.dist = val + self.offset
                        elif not isnan(val):
                                self.dist = val + self.offset
+                               self.last_update = datetime.now()
                                self.pub.publish(self.distance())
                                last_val = val
                        sleep(0.1)
                                self.pub.publish(self.distance())
                                last_val = val
                        sleep(0.1)
@@ -113,59 +127,84 @@ class Position:
                self.filter_x.x_est = pos[0]
                self.filter_y.x_est = pos[1]
 
                self.filter_x.x_est = pos[0]
                self.filter_y.x_est = pos[1]
 
-               # run kalman
-               x = self.filter_x.run(x)
-               y = self.filter_y.run(y)
+               # run kalman if new measurements are valid
+               if x != None and y != None:
+                       x = self.filter_x.run(x)
+                       y = self.filter_y.run(y)
+
+                       # Update covariance
+                       dist = np.linalg.norm([x, y])
+                       self.filter_x.set_measure_cov(np.polyval([0.017795,  -0.021832, 0.010968], dist))
+                       self.filter_y.set_measure_cov(np.polyval([0.0060314, -0.013387, 0.0065049], dist))
+               else:
+                       x = self.filter_x.x_est
+                       y = self.filter_y.x_est
 
                self.last_time = current_time
                return x,y
 
 
 
                self.last_time = current_time
                return x,y
 
 
+def handle_center_call(req):
+       diff = dwleft.distance_valid() - dwright.distance_valid()
+       dwleft.offset -= diff/2
+       dwright.offset += diff/2
+       rospy.loginfo("Centering to %.2f %.2f", dwleft.offset, dwright.offset)
+       return DWM1000CenterResponse()
+
 if __name__ == "__main__":
 if __name__ == "__main__":
-       rospy.init_node('DW1000')
-       dwleft  = DW1000("uwb_dist_left",  0xc2, +0.0)
-       dwright = DW1000("uwb_dist_right", 0xc0, -0.0)
-       dist_l_r = 0.285
+       rospy.init_node('DWM1000', log_level=rospy.DEBUG)
+       dwleft  = DW1000("uwb_dist_left",  0xc2, +0.00)
+       dwright = DW1000("uwb_dist_right", 0xc0, -0.00)
+       dist_l_r = 0.285 # Distance between both DWM1000
        rate = rospy.Rate(10)
        pos = Position()
        tf_broadcaster = tf.broadcaster.TransformBroadcaster()
        rate = rospy.Rate(10)
        pos = Position()
        tf_broadcaster = tf.broadcaster.TransformBroadcaster()
+       rospy.Service('/DWM1000/center', DWM1000Center, handle_center_call)
 
        while not rospy.is_shutdown() and dwleft.is_alive() and dwright.is_alive():
 
        while not rospy.is_shutdown() and dwleft.is_alive() and dwright.is_alive():
-               dist_left = dwleft.distance()
-               dist_right = dwright.distance()
-               dir = "left" if (dist_left < dist_right) else "right"
-
-               diff = abs(dist_left - dist_right)
-               if diff >= dist_l_r:
-                       # difference to high, correct to maximum
-                       off = diff - dist_l_r + 0.01
-                       if dist_left > dist_right:
-                               dist_left -= off/2
-                               dist_right += off/2
+               dist_left = dwleft.distance_valid()
+               dist_right = dwright.distance_valid()
+               if dist_left == None or dist_right == None:
+                       rospy.logerr_throttle(10, "no valid sensor update")
+                       # run kalman prediction only
+                       pos.filter(None, None)
+               else:
+                       dir = "left" if (dist_left < dist_right) else "right"
+
+                       diff = abs(dist_left - dist_right)
+                       if diff >= dist_l_r:
+                               # difference to high, correct to maximum
+                               off = diff - dist_l_r + 0.01
+                               if dist_left > dist_right:
+                                       dist_left -= off/2
+                                       dist_right += off/2
+                               else:
+                                       dist_left += off/2
+                                       dist_right -= off/2
+                       rospy.logdebug("%.2f %.2f %.2f %.2f %s", dwleft.distance(), dwright.distance(), dist_left, dist_right, dir)
+
+                       a_r = (-dist_right**2 + dist_left**2 - dist_l_r**2) / (-2*dist_l_r)
+                       x = dist_l_r/2 - a_r
+                       t = dist_right**2 - a_r**2
+                       if t >= 0:
+                               y = sqrt(t)
+                               rospy.logdebug("x=%.2f, y=%.2f", x, y)
+                               # Rotate 90 deg
+                               x, y = (y, -x)
+
+                               x, y = pos.filter(x, y)
+                               tf_broadcaster.sendTransform((x, y, 0.0), (0, 0, 0, 1), rospy.Time.now(), "uwb_beacon", "base_footprint")
+
+                               if VISULAIZE:
+                                       circle_left = plt.Circle((-dist_l_r/2, 0), dwleft.distance, color='red', fill=False)
+                                       circle_right = plt.Circle((dist_l_r/2, 0), dwright.distance, color='green', fill=False)
+                                       plt.gca().add_patch(circle_left)
+                                       plt.gca().add_patch(circle_right)
+                                       plt.grid(True)
+                                       plt.axis('scaled')
+                                       plt.show()
                        else:
                        else:
-                               dist_left += off/2
-                               dist_right -= off/2
-               print "%.2f %.2f %.2f %.2f %s" % (dwleft.distance(), dwright.distance(), dist_left, dist_right, dir)
-
-               a_r = (-dist_right**2 + dist_left**2 - dist_l_r**2) / (-2*dist_l_r)
-               x = dist_l_r/2 - a_r
-               t = dist_right**2 - a_r**2
-               if t >= 0:
-                       y = sqrt(t)
-                       print x,y
-                       # Rotate 90 deg
-                       x, y = (y, -x)
-
-                       x, y = pos.filter(x, y)
-                       tf_broadcaster.sendTransform((x, y, 0.0), (0, 0, 0, 1), rospy.Time.now(), "uwb_beacon", "base_footprint")
-
-                       if VISULAIZE:
-                               circle_left = plt.Circle((-dist_l_r/2, 0), dwleft.distance, color='red', fill=False)
-                               circle_right = plt.Circle((dist_l_r/2, 0), dwright.distance, color='green', fill=False)
-                               plt.gca().add_patch(circle_left)
-                               plt.gca().add_patch(circle_right)
-                               plt.grid(True)
-                               plt.axis('scaled')
-                               plt.show()
+                               # No current position, still need up update kalman prediction
+                               pos.filter(None, None)
 
                rate.sleep()
 
                rate.sleep()