Drone now uses firmware version provided by the drone configuration, …

…by default

ARDroneControlLibrary/ARDroneControlLibrary.csproj

@@ -56,10 +56,13 @@
     <Compile Include="Commands\SetControlModeCommand.cs" />
     <Compile Include="Commands\SwitchCameraCommand.cs" />
     <Compile Include="Commands\WatchDogCommand.cs" />
-    <Compile Include="Data\Firmware.cs" />
+    <Compile Include="Data\DroneFirmwareVersion.cs" />
+    <Compile Include="Data\SupportedFirmwareVersion.cs" />
+    <Compile Include="Data\Helpers\DisplayStringAttribute.cs" />
     <Compile Include="Data\InternalDroneConfiguration.cs" />
     <Compile Include="Data\InternalDroneConfigurationState.cs" />
     <Compile Include="Data\NavigationData.cs" />
+    <Compile Include="Data\Helpers\VersionBetweenAttribute.cs" />
     <Compile Include="DroneConfig.cs" />
     <Compile Include="DroneControl.cs" />
     <Compile Include="Events\DroneEvents.cs" />

ARDroneControlLibrary/Data/DroneFirmwareVersion.cs

@@ -0,0 +1,187 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Reflection;
+using ARDrone.Control.Data.Helpers;
+
+namespace ARDrone.Control.Data
+{
+    public class DroneFirmwareVersion
+    {
+        public static readonly DroneFirmwareVersion MaxVersion = new DroneFirmwareVersion(Int32.MaxValue.ToString());
+        public static readonly DroneFirmwareVersion MinVersion = new DroneFirmwareVersion(Int32.MinValue.ToString());
+
+        public const String MaxVersionString = "MaxVersion";
+        public const String MinVersionString = "MinVersion";
+
+        private String versionString;
+        private int[] versionParts;
+
+        public DroneFirmwareVersion(String versionString)
+        {
+            if (versionString == MaxVersionString)
+            {
+                versionString = MaxVersion.versionString;
+            }
+            if (versionString == MinVersionString)
+            {
+                versionString = MinVersion.versionString;
+            }
+
+            this.versionString = versionString;
+            this.versionParts = GetVersionParts();
+        }
+
+        private int[] GetVersionParts()
+        {
+            String[] versionPartStrings = versionString.Split('.');
+            int[] versionParts = new int[versionPartStrings.Length];
+
+            for (int i = 0; i < versionPartStrings.Length; i++)
+            {
+                String versionPartString = versionPartStrings[i];
+                try
+                {
+                    versionParts[i] = Int32.Parse(versionPartString);
+                }
+                catch (Exception)
+                {
+                    versionParts[i] = -1;
+                }
+            }
+
+            return versionParts;
+        }
+
+        public SupportedFirmwareVersion GetSupportedFirmwareVersion()
+        {
+            foreach (SupportedFirmwareVersion supportedFirmwareVersion in Enum.GetValues(typeof(SupportedFirmwareVersion)))
+            {
+                if (IsInRange(supportedFirmwareVersion))
+                {
+                    return supportedFirmwareVersion;
+                }
+            }
+
+            return DroneConfig.DefaultSupportedFirmwareVersion;
+        }
+
+        private bool IsInRange(SupportedFirmwareVersion supportedFirmwareVersion)
+        {
+            VersionBetweenAttribute versionRange = GetVersionRange(supportedFirmwareVersion);
+
+            if (versionRange == null)
+            {
+                return false;
+            }
+
+            if (versionRange.MinVersionState == VersionState.Exclusive && this <= versionRange.MinVersion)
+            {
+                return false;
+            }
+            if (versionRange.MinVersionState == VersionState.Inclusive && this < versionRange.MinVersion)
+            {
+                return false;
+            }
+
+            if (versionRange.MaxVersionState == VersionState.Exclusive && this >= versionRange.MaxVersion)
+            {
+                return false;
+            }
+            if (versionRange.MaxVersionState == VersionState.Inclusive && this > versionRange.MaxVersion)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private VersionBetweenAttribute GetVersionRange(SupportedFirmwareVersion supportedFirmwareVersion)
+        {
+            MemberInfo memberInfo = typeof(SupportedFirmwareVersion).GetMember(supportedFirmwareVersion.ToString()).FirstOrDefault();
+
+            if (memberInfo != null)
+            {
+                VersionBetweenAttribute attribute = (VersionBetweenAttribute)memberInfo.GetCustomAttributes(typeof(VersionBetweenAttribute), false).FirstOrDefault();
+                return attribute;
+            }
+
+            return null;
+        }
+
+        public override int GetHashCode()
+        {
+            int hashValue = 0;
+            for (int i = 0; i < versionParts.Length; i++)
+            {
+                hashValue = (hashValue + versionParts[i]) * 100;
+            }
+
+            return hashValue;
+        }
+
+        public override bool Equals(Object obj)
+        {
+            if (obj.GetType() == typeof(DroneFirmwareVersion))
+            {
+                return (DroneFirmwareVersion)obj == this;
+            }
+
+            return false;
+        }
+
+        public static bool operator >(DroneFirmwareVersion version1, DroneFirmwareVersion version2)
+        {
+            return Compare(version1, version2) > 0;
+        }
+
+        public static bool operator <(DroneFirmwareVersion version1, DroneFirmwareVersion version2)
+        {
+            return Compare(version1, version2) < 0;
+        }
+
+        public static bool operator ==(DroneFirmwareVersion version1, DroneFirmwareVersion version2)
+        {
+            return Compare(version1, version2) == 0;
+        }
+
+        public static bool operator !=(DroneFirmwareVersion version1, DroneFirmwareVersion version2)
+        {
+            return Compare(version1, version2) != 0;
+        }
+
+        public static bool operator >=(DroneFirmwareVersion version1, DroneFirmwareVersion version2)
+        {
+            return Compare(version1, version2) >= 0;
+        }
+
+        public static bool operator <=(DroneFirmwareVersion version1, DroneFirmwareVersion version2)
+        {
+            return Compare(version1, version2) <= 0;
+        }
+
+        private static int Compare(DroneFirmwareVersion version1, DroneFirmwareVersion version2)
+        {
+            int[] version1Parts = version1.versionParts;
+            int[] version2Parts = version2.versionParts;
+
+            for (int i = 0; i < Math.Max(version1Parts.Length, version2Parts.Length); i++)
+            {
+                int version1Part = version1Parts.Length > i ? version1Parts[i] : -1;
+                int version2Part = version2Parts.Length > i ? version2Parts[i] : -1;
+
+                if (version1Part > version2Part)
+                {
+                    return 1;
+                }
+                else if (version2Part > version1Part)
+                {
+                    return -1;
+                }
+            }
+
+            return 0;
+        }
+    }
+}

ARDroneControlLibrary/Data/Helpers/DisplayStringAttribute.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ARDrone.Control.Data.Helpers
+{
+    [AttributeUsage(AttributeTargets.Field)]
+    public sealed class DisplayStringAttribute : Attribute
+    {
+        private readonly string value;
+
+        public DisplayStringAttribute(string value)
+        {
+            this.value = value;
+        }
+
+        public string Value
+        {
+            get { return value; }
+        }
+    }
+}

ARDroneControlLibrary/Data/Helpers/VersionBetweenAttribute.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ARDrone.Control.Data.Helpers
+{
+    [AttributeUsage(AttributeTargets.Field)]
+    public class VersionBetweenAttribute : System.Attribute
+    {
+        private DroneFirmwareVersion minVersion;
+        private VersionState minVersionState;
+
+        private DroneFirmwareVersion maxVersion;
+        private VersionState maxVersionState;
+
+        public VersionBetweenAttribute(VersionState minVersionState, String minVersionString, VersionState maxVersionState, String maxVersionString)
+        {
+            this.minVersion = new DroneFirmwareVersion(minVersionString);
+            this.minVersionState = minVersionState;
+
+            this.maxVersion = new DroneFirmwareVersion(maxVersionString);
+            this.maxVersionState = maxVersionState;
+        }
+
+        public DroneFirmwareVersion MinVersion
+        {
+            get
+            {
+                return minVersion;
+            }
+        }
+
+        public VersionState MinVersionState
+        {
+            get
+            {
+                return minVersionState;
+            }
+        }
+
+        public DroneFirmwareVersion MaxVersion
+        {
+            get
+            {
+                return maxVersion;
+            }
+        }
+
+        public VersionState MaxVersionState
+        {
+            get
+            {
+                return maxVersionState;
+            }
+        }
+    }
+
+    public enum VersionState
+    {
+        Inclusive,
+        Exclusive,
+    }
+}

ARDroneControlLibrary/Data/Firmware.cs → ARDroneControlLibrary/Data/SupportedFirmwareVersion.cs

@@ -12,31 +12,19 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using ARDrone.Control.Data.Helpers;
 
 namespace ARDrone.Control.Data
 {
-    [AttributeUsage(AttributeTargets.Field)]
-    public sealed class DisplayStringAttribute : Attribute
-    {
-        private readonly string value;
-
-        public DisplayStringAttribute(string value)
-        {
-            this.value = value;
-        }
-
-        public string Value
-        {
-            get { return value; }
-        }
-    }
-
     public enum SupportedFirmwareVersion
     {
+        [VersionBetweenAttribute(VersionState.Inclusive, DroneFirmwareVersion.MinVersionString, VersionState.Inclusive, "1.3.3")]
         [DisplayStringAttribute("Firmware 1.3.3 or below")]
         Firmware_133_Or_Below,
+        [VersionBetweenAttribute(VersionState.Exclusive, "1.3.3", VersionState.Inclusive, "1.6.4")]
         [DisplayStringAttribute("Firmware between 1.5.x and 1.6.4  (exclusive)")]
         Firmware_Between_15x_And_164,
+        [VersionBetweenAttribute(VersionState.Exclusive, "1.6.4", VersionState.Inclusive, DroneFirmwareVersion.MaxVersionString)]
         [DisplayStringAttribute("Firmware 1.6.4 or above")]
         Firmware_164_Or_Above
     }

ARDroneControlLibrary/DroneConfig.cs

@@ -22,6 +22,7 @@ namespace ARDrone.Control
     [Serializable()]
     public class DroneConfig
     {
+        public const SupportedFirmwareVersion DefaultSupportedFirmwareVersion = SupportedFirmwareVersion.Firmware_164_Or_Above;
         private const String serializationFileName = "droneConfig.xml";
 
         private SerializationUtils serializationUtils;
@@ -37,6 +38,7 @@ public class DroneConfig
 
         private int timeoutValue;
 
+        private bool useSpecificFirmwareVersion;
         private SupportedFirmwareVersion firmwareVersion;
 
         private DroneCameraMode defaultCameraMode;
@@ -58,7 +60,8 @@ public DroneConfig()
             commandPort = 5556;
             controlInfoPort = 5559;
 
-            firmwareVersion = SupportedFirmwareVersion.Firmware_133_Or_Below;
+            useSpecificFirmwareVersion = false;
+            firmwareVersion = SupportedFirmwareVersion.DefaultSupportedFirmwareVersion;
 
             timeoutValue = 500;
             defaultCameraMode = DroneCameraMode.FrontCamera;
@@ -75,6 +78,7 @@ private void CopySettingsFrom(DroneConfig droneConfig)
             this.CommandPort = droneConfig.CommandPort;
             this.ControlInfoPort = droneConfig.ControlInfoPort;
 
+            this.UseSpecificFirmwareVersion = droneConfig.UseSpecificFirmwareVersion;
             this.FirmwareVersion = droneConfig.FirmwareVersion;
         }
 
@@ -140,6 +144,12 @@ public int TimeoutValue
             set { CheckForDroneConfigState(); timeoutValue = value; }
         }
 
+        public bool UseSpecificFirmwareVersion
+        {
+            get { return useSpecificFirmwareVersion; }
+            set { useSpecificFirmwareVersion = value; }
+        }
+
         public SupportedFirmwareVersion FirmwareVersion
         {
             get { return firmwareVersion; }