Adds tests and fixes dict objects in channels.

Author: tcr3dr

dronekit/lib/__init__.py

@@ -396,15 +396,50 @@ def decorator(fn):
                 self.add_attribute_listener(name, fn)
         return decorator
 
+
+class ChannelsOverride(dict):
+    def __init__(self, vehicle):
+        self._vehicle = vehicle
+        self._count = 8 # Fixed by MAVLink
+
+    def __getitem__(self, key):
+        return dict.__getitem__(self, str(key))
+
+    def __setitem__(self, key, value):
+        if not (int(key) >= 0 and int(key) < self._count):
+            raise Exception('Invalid channel index %s' % key)
+        if not value:
+            dict.__delitem__(self, str(key))
+        else:
+            dict.__setitem__(self, str(key), value)
+        self._send()
+
+    def __delitem__(self, key):
+        dict.__delitem__(self, str(key))
+        self._send()
+
+    def __len__(self):
+        return self._count
+
+    def _send(self):
+        overrides = [0] * 8
+        for k, v in self.iteritems():
+            overrides[int(k)-1] = v
+        self._vehicle._master.mav.rc_channels_override_send(0, 0, *overrides)
+
+
 class Channels(dict):
     """
     Implements RC object.
     """
 
     def __init__(self, vehicle, count):
+        self._vehicle = vehicle
         self._count = count
+        self._overrides = ChannelsOverride(vehicle)
+
+        # populate readback
         self._readonly = False
-        self._overrides = {}
         for k in range(0, count):
             self[k + 1] = None
         self._readonly = True
@@ -413,34 +448,39 @@ def __init__(self, vehicle, count):
     def count(self):
         return self._count
 
+    def __getitem__(self, key):
+        return dict.__getitem__(self, str(key))
+
     def __setitem__(self, key, value):
         if self._readonly:
             raise TypeError('__setitem__ is not supported on Channels object')
-        return dict.__setitem__(self, key, value)
+        return dict.__setitem__(self, str(key), value)
 
     def __len__(self):
         return self._count
 
     def _update_channel(self, channel, value):
         # If we have channels on different ports, we expand the Channels
         # object to support them.
-        channel = str(channel)
+        channel = int(channel)
         self._readonly = False
         self[channel] = value
         self._readonly = True
-        self._count = max(self._count, int(channel))
+        self._count = max(self._count, channel)
 
     @property
     def overrides(self):
-        return copy.copy(self._overrides)
+        return self._overrides
 
     @overrides.setter
     def overrides(self, newch):
-        self._overrides = {}
         for k, v in newch.iteritems():
             if v:
                 self._overrides[str(k)] = v
-        self._master.mav.rc_channels_override_send(0, 0, *list(self._overrides.values()))
+            else:
+                del self._overrides[str(k)]
+        self._overrides._send()
+
 
 class Vehicle(HasObservers):
     """

dronekit/test/sitl/test_channels.py

@@ -0,0 +1,58 @@
+from dronekit import connect
+from dronekit.lib import VehicleMode
+from pymavlink import mavutil
+import time
+from dronekit import connect, VehicleMode, LocationGlobal
+from dronekit.test import with_sitl
+from nose.tools import assert_equals, assert_not_equals
+
+def assert_readback(vehicle, values):
+    i = 10
+    while i > 0:
+        time.sleep(.1)
+        i -= .1
+        for k, v in values.iteritems():
+            if vehicle.channels[k] != v:
+                continue
+        break
+    if i <= 0:
+        raise Exception('Did not match in channels readback %s' % values)
+
+@with_sitl
+def test_timeout(connpath):
+    vehicle = connect(connpath, wait_ready=True)
+
+    assert_equals(len(vehicle.channels), 8)
+    assert_equals(len(vehicle.channels.overrides), 8)
+
+    assert_equals(sorted(vehicle.channels.keys()), [str(x) for x in range(1, 9)])
+    assert_equals(sorted(vehicle.channels.overrides.keys()), [])
+
+    assert_equals(type(vehicle.channels['1']), int)
+    assert_equals(type(vehicle.channels['2']), int)
+    assert_equals(type(vehicle.channels['7']), int)
+    assert_equals(type(vehicle.channels['8']), int)
+    assert_equals(type(vehicle.channels[1]), int)
+    assert_equals(type(vehicle.channels[2]), int)
+    assert_equals(type(vehicle.channels[7]), int)
+    assert_equals(type(vehicle.channels[8]), int)
+    
+    vehicle.channels.overrides = {'1': 1010}
+    assert_readback(vehicle, {'1': 1010})
+
+    vehicle.channels.overrides = {'2': 1020}
+    assert_readback(vehicle, {'1': 1500, '2': 1010})
+
+    vehicle.channels.overrides['1'] = 1010
+    assert_readback(vehicle, {'1': 1010, '2': 1020})
+
+    del vehicle.channels.overrides['1']
+    assert_readback(vehicle, {'1': 1500, '2': 1020})
+
+    vehicle.channels.overrides = {'1': 1010, '2': None}
+    assert_readback(vehicle, {'1': 1010, '2': 1500})
+
+    vehicle.channels.overrides['1'] = None
+    assert_readback(vehicle, {'1': 1500, '2': 1500})
+
+    vehicle.close()