Display automatically set port voltage value

jonnew · jonnew · commit c370c58f692c · 2025-04-22T16:09:06.000-04:00
- When the PortVoltage is null, the port voltage will be set
  automatically. If this procedure succeeds, the voltage will be
  displayed in the text box as "X.X (Auto)" where X.X is the voltage
  that is applied to the port.
- This text will only appear while the workflow is running. It will
  revert back to null after the workflow is stopped.
- If the voltage is set manually, the value will persist.
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -13,7 +13,7 @@
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
     <UseArtifactsOutput>true</UseArtifactsOutput>
     <PackageIcon>icon.png</PackageIcon>
-    <VersionPrefix>0.4.5</VersionPrefix>
+    <VersionPrefix>0.5.0</VersionPrefix>
     <VersionSuffix></VersionSuffix>
     <LangVersion>10.0</LangVersion>
     <Features>strict</Features>
diff --git a/OpenEphys.Onix1/AutoPortVoltage.cs b/OpenEphys.Onix1/AutoPortVoltage.cs
@@ -0,0 +1,103 @@
+﻿using System;
+using System.ComponentModel;
+using System.Globalization;
+using System.Xml.Serialization;
+
+namespace OpenEphys.Onix1
+{
+    /// <summary>
+    /// Represents a, possibly automatically set, port voltage. 
+    /// </summary>
+    public class AutoPortVoltage
+    {
+        /// <summary>
+        /// Gets or sets a value the requested port voltage. If null, the voltage will be set automatically.
+        /// </summary>
+        public double? Requested { get; set; }
+
+        /// <summary>
+        /// Gets or sets the currently applied port voltage
+        /// </summary>
+        [XmlIgnore]
+        public double? Applied { get; internal set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoPortVoltage"/> class.
+        /// </summary>
+        public AutoPortVoltage() 
+        {
+            Requested = null;
+            Applied = null;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoPortVoltage"/> class.
+        /// </summary>
+        /// <param name="value">A value determining the requested port voltage</param>
+        public AutoPortVoltage(double? value) 
+        {
+            Requested = value;
+            Applied = null;
+        }
+    }
+
+    internal class PortVoltageConverter : TypeConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            if (destinationType == typeof(string))
+                return true;
+
+            return base.CanConvertTo(context, destinationType);
+        }
+
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            if (destinationType == typeof(string) && value is AutoPortVoltage portVoltage)
+            {
+                if (portVoltage.Requested.HasValue)
+                {
+                    return string.Format($"{portVoltage.Requested:0.0}");
+                }
+                else if (portVoltage.Applied.HasValue)
+                {
+                    return $"{portVoltage.Applied:0.0} (Auto)";
+                }
+                else
+                {
+                    return "";
+                } 
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            if (sourceType == typeof(string))
+                return true;
+
+            return base.CanConvertFrom(context, sourceType);
+        }
+
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value is string stringValue)
+            {
+
+                if (string.IsNullOrEmpty(stringValue))
+                {
+                    return new AutoPortVoltage(null);
+                }
+                else if (double.TryParse(stringValue, NumberStyles.Number, culture ?? CultureInfo.CurrentCulture, out double result))
+                {
+                    return new AutoPortVoltage(result);
+                }
+
+                throw new FormatException($"'{stringValue}' is not a valid value for PortVoltage.");
+            }
+
+            return base.ConvertFrom(context, culture, value);
+        }
+    }
+}
diff --git a/OpenEphys.Onix1/ConfigureHeadstage64.cs b/OpenEphys.Onix1/ConfigureHeadstage64.cs
@@ -125,11 +125,12 @@ public PortName Port
         /// Supplying higher voltages may result in damage.
         /// </para>
         /// </remarks>
-        [Description("If defined, it will override automated voltage discovery and apply the specified voltage" +
-                     "to the headstage. Warning: this device requires 5.5V to 6.0V for proper operation." +
-                     "Supplying higher voltages may result in damage to the headstage.")]
+        [Description("If defined, it will override automated voltage discovery and apply the specified voltage " +
+                     "to the headstage. Warning: this device requires 5.5V to 6.0V, measured at the headstage, " +
+                     "for proper operation. Supplying higher voltages may result in damage to the headstage.")]
         [Category(ConfigurationCategory)]
-        public double? PortVoltage
+        [TypeConverter(typeof(PortVoltageConverter))]
+        public AutoPortVoltage PortVoltage
         {
             get => PortControl.PortVoltage;
             set => PortControl.PortVoltage = value;
@@ -147,34 +148,38 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()
 
         class ConfigureHeadstage64PortController : ConfigurePortController
         {
-            protected override bool ConfigurePortVoltage(DeviceContext device)
+            protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)
             {
                 // WONTFIX: It takes a huge amount of time to get to 0, almost 10 seconds. The best we can do
                 // at the moment is drive port voltage to minimum which is an active process and then settle
                 // from there to zero volts. This requires a hardware revision that discharges the headstage
                 // between cycles to fix.
-                const uint MinVoltage = 33;
-                const uint MaxVoltage = 60;
-                const uint VoltageOffset = 34;
-                const uint VoltageIncrement = 02;
+                const double MinVoltage = 3.3;
+                const double MaxVoltage = 6.0;
+                const double VoltageOffset = 3.4;
+                const double VoltageIncrement = 0.2;
 
                 // Start with highest voltage and ramp it down to find lowest lock voltage
-                var voltage = MaxVoltage;
+                voltage = MaxVoltage;
                 for (; voltage >= MinVoltage; voltage -= VoltageIncrement)
                 {
-                    device.WriteRegister(PortController.PORTVOLTAGE, voltage);
+                    device.WriteRegister(PortController.PORTVOLTAGE, (uint)(10 * voltage));
                     Thread.Sleep(200);
                     if (!CheckLinkState(device))
                     {
-                        if (voltage == MaxVoltage) return false;
+                        if (voltage == MaxVoltage)
+                        {
+                            return false;
+                        }
                         else break;
                     }
                 }
 
-                device.WriteRegister(PortController.PORTVOLTAGE, MinVoltage);
+                device.WriteRegister(PortController.PORTVOLTAGE, (uint)(10 * MinVoltage));
                 device.WriteRegister(PortController.PORTVOLTAGE, 0);
                 Thread.Sleep(1000);
-                device.WriteRegister(PortController.PORTVOLTAGE, voltage + VoltageOffset);
+                voltage += VoltageOffset;
+                device.WriteRegister(PortController.PORTVOLTAGE, (uint)(10 * voltage));
                 Thread.Sleep(200);
                 return CheckLinkState(device);
             }
diff --git a/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV1e.cs b/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV1e.cs
@@ -89,7 +89,8 @@ public PortName Port
             "the specified voltage to the headstage. Warning: this device requires 3.8V to 5.0V " +
             "for proper operation. Higher voltages can damage the headstage.")]
         [Category(ConfigurationCategory)]
-        public double? PortVoltage
+        [TypeConverter(typeof(PortVoltageConverter))]
+        public AutoPortVoltage PortVoltage
         {
             get => PortControl.PortVoltage;
             set => PortControl.PortVoltage = value;
@@ -104,20 +105,22 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()
 
         class ConfigureNeuropixelsV1ePortController : ConfigurePortController
         {
-            protected override bool ConfigurePortVoltage(DeviceContext device)
+            protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)
             {
                 const double MinVoltage = 3.3;
                 const double MaxVoltage = 5.5;
                 const double VoltageOffset = 1.0;
                 const double VoltageIncrement = 0.2;
 
-                for (double voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)
+                voltage = MinVoltage;
+                for (; voltage <= MaxVoltage; voltage += VoltageIncrement)
                 {
                     SetVoltage(device, voltage);
 
                     if (CheckLinkState(device))
                     {
-                        SetVoltage(device, voltage + VoltageOffset);
+                        voltage += VoltageOffset;
+                        SetVoltage(device, voltage);
                         return CheckLinkState(device);
                     }
                 }
diff --git a/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV1f.cs b/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV1f.cs
@@ -117,7 +117,8 @@ public PortName Port
         "the specified voltage to the headstage. Warning: this device requires 4.5V to 5.5V " +
         "for proper operation. Higher voltages can damage the headstage.")]
         [Category(ConfigurationCategory)]
-        public double? PortVoltage
+        [TypeConverter(typeof(PortVoltageConverter))]
+        public AutoPortVoltage PortVoltage
         {
             get => PortControl.PortVoltage;
             set => PortControl.PortVoltage = value;
@@ -134,39 +135,24 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()
 
         class ConfigureNeuropixels1fHeadstageLinkController : ConfigurePortController
         {
-            // TODO: Needs more testing
-            protected override bool ConfigurePortVoltage(DeviceContext device)
+            protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)
             {
-                if (PortVoltage == null)
-                {
-                    const double MinVoltage = 5.0;
-                    const double MaxVoltage = 7.0;
-                    const double VoltageOffset = 1.0;
-                    const double VoltageIncrement = 0.2;
+                const double MinVoltage = 5.0;
+                const double MaxVoltage = 7.0;
+                const double VoltageOffset = 1.0;
+                const double VoltageIncrement = 0.2;
 
-                    for (double voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)
+                voltage = MinVoltage;
+                for (; voltage <= MaxVoltage; voltage += VoltageIncrement)
+                {
+                    SetVoltage(device, voltage);
+                    if (CheckLinkState(device))
                     {
+                        voltage += VoltageOffset;
                         SetVoltage(device, voltage);
-                        if (CheckLinkState(device))
-                        {
-                            SetVoltage(device, voltage + VoltageOffset);
-                            return CheckLinkState(device);
-                        }
+                        return CheckLinkState(device);
                     }
-                    return false;
-                }
-                else
-                {
-                    SetVoltage(device, (double)PortVoltage);
                 }
-
-                if (CheckLinkState(device))
-                {
-                    device.Context.Reset();
-                    Thread.Sleep(200);
-                    return true;
-                }
-
                 return false;
             }
 
diff --git a/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV2e.cs b/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV2e.cs
@@ -88,7 +88,8 @@ public PortName Port
             "the specified voltage to the headstage. Warning: this device requires 3.0V to 5.5V " +
             "for proper operation. Higher voltages can damage the headstage.")]
         [Category(ConfigurationCategory)]
-        public double? PortVoltage
+        [TypeConverter(typeof(PortVoltageConverter))]
+        public AutoPortVoltage PortVoltage
         {
             get => PortControl.PortVoltage;
             set => PortControl.PortVoltage = value;
diff --git a/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV2eBeta.cs b/OpenEphys.Onix1/ConfigureHeadstageNeuropixelsV2eBeta.cs
@@ -88,7 +88,8 @@ public PortName Port
             "the specified voltage to the headstage. Warning: this device requires 3.0V to 5.0V " +
             "for proper operation. Higher voltages can damage the headstage.")]
         [Category(ConfigurationCategory)]
-        public double? PortVoltage
+        [TypeConverter(typeof(PortVoltageConverter))]
+        public AutoPortVoltage PortVoltage
         {
             get => PortControl.PortVoltage;
             set => PortControl.PortVoltage = value;
diff --git a/OpenEphys.Onix1/ConfigureHeadstageNric1384.cs b/OpenEphys.Onix1/ConfigureHeadstageNric1384.cs
@@ -95,7 +95,8 @@ public PortName Port
             "the specified voltage to the headstage. Warning: this device requires 3.8V to 5.5V " +
             "for proper operation. Higher voltages can damage the headstage.")]
         [Category(ConfigurationCategory)]
-        public double? PortVoltage
+        [TypeConverter(typeof(PortVoltageConverter))]
+        public AutoPortVoltage PortVoltage
         {
             get => PortControl.PortVoltage;
             set => PortControl.PortVoltage = value;
@@ -110,19 +111,21 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()
 
         class ConfigureHeadstageNric1384PortController : ConfigurePortController
         {
-            protected override bool ConfigurePortVoltage(DeviceContext device)
+            protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)
             {
                 const double MinVoltage = 3.8;
                 const double MaxVoltage = 5.5;
                 const double VoltageOffset = 0.7;
                 const double VoltageIncrement = 0.2;
 
-                for (var voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)
+                voltage = MinVoltage;
+                for (; voltage <= MaxVoltage; voltage += VoltageIncrement)
                 {
                     SetPortVoltage(device, voltage);
                     if (base.CheckLinkState(device))
                     {
-                        SetPortVoltage(device, voltage + VoltageOffset);
+                        voltage += VoltageOffset;
+                        SetPortVoltage(device, voltage);
                         return CheckLinkState(device);
                     }
                 }
diff --git a/OpenEphys.Onix1/ConfigureHeadstageRhs2116.cs b/OpenEphys.Onix1/ConfigureHeadstageRhs2116.cs
@@ -100,7 +100,8 @@ public PortName Port
                      "to the headstage. Warning: this device requires 3.4V to 4.4V for proper operation." +
                      "Supplying higher voltages may result in damage to the headstage.")]
         [Category(ConfigurationCategory)]
-        public double? PortVoltage
+        [TypeConverter(typeof(PortVoltageConverter))]
+        public AutoPortVoltage PortVoltage
         {
             get => LinkController.PortVoltage;
             set => LinkController.PortVoltage = value;
@@ -115,19 +116,21 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()
 
         class ConfigureHeadstageRhs2116LinkController : ConfigurePortController
         {
-            protected override bool ConfigurePortVoltage(DeviceContext device)
+            protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)
             {
                 const double MinVoltage = 3.3;
                 const double MaxVoltage = 4.4;
                 const double VoltageOffset = 2.0;
                 const double VoltageIncrement = 0.2;
 
-                for (var voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)
+                voltage = MinVoltage;
+                for (; voltage <= MaxVoltage; voltage += VoltageIncrement)
                 {
                     SetPortVoltage(device, voltage);
                     if (base.CheckLinkState(device))
                     {
-                        SetPortVoltage(device, voltage + VoltageOffset);
+                        voltage += VoltageOffset;
+                        SetPortVoltage(device, voltage);
                         return CheckLinkState(device);
                     }
                 }
diff --git a/OpenEphys.Onix1/ConfigureNeuropixelsV2ePortController.cs b/OpenEphys.Onix1/ConfigureNeuropixelsV2ePortController.cs
@@ -4,20 +4,22 @@ namespace OpenEphys.Onix1
 {
     class ConfigureNeuropixelsV2ePortController : ConfigurePortController
     {
-        protected override bool ConfigurePortVoltage(DeviceContext device)
+        protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)
         {
             const double MinVoltage = 3.3;
             const double MaxVoltage = 5.5;
             const double VoltageOffset = 1.0;
             const double VoltageIncrement = 0.2;
 
-            for (double voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)
+            voltage = MinVoltage;
+            for (; voltage <= MaxVoltage; voltage += VoltageIncrement)
             {
                 SetVoltage(device, voltage);
 
                 if (CheckLinkState(device))
                 {
-                    SetVoltage(device, voltage + VoltageOffset);
+                    voltage += VoltageOffset;
+                    SetVoltage(device, voltage);
                     return CheckLinkState(device);
                 }
             }
diff --git a/OpenEphys.Onix1/ConfigurePortController.cs b/OpenEphys.Onix1/ConfigurePortController.cs
diff --git a/OpenEphys.Onix1/ConfigureUclaMiniscopeV4.cs b/OpenEphys.Onix1/ConfigureUclaMiniscopeV4.cs
diff --git a/OpenEphys.Onix1/Rhs2116Stimulus.cs b/OpenEphys.Onix1/Rhs2116Stimulus.cs

Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,8 @@ public PortName Port`
`89`	`89`	`"the specified voltage to the headstage. Warning: this device requires 3.8V to 5.0V " +`
`90`	`90`	`"for proper operation. Higher voltages can damage the headstage.")]`
`91`	`91`	`[Category(ConfigurationCategory)]`
`92`		`- public double? PortVoltage`
	`92`	`+ [TypeConverter(typeof(PortVoltageConverter))]`
	`93`	`+ public AutoPortVoltage PortVoltage`
`93`	`94`	`{`
`94`	`95`	`get => PortControl.PortVoltage;`
`95`	`96`	`set => PortControl.PortVoltage = value;`
`@@ -104,20 +105,22 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()`
`104`	`105`
`105`	`106`	`class ConfigureNeuropixelsV1ePortController : ConfigurePortController`
`106`	`107`	`{`
`107`		`- protected override bool ConfigurePortVoltage(DeviceContext device)`
	`108`	`+ protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)`
`108`	`109`	`{`
`109`	`110`	`const double MinVoltage = 3.3;`
`110`	`111`	`const double MaxVoltage = 5.5;`
`111`	`112`	`const double VoltageOffset = 1.0;`
`112`	`113`	`const double VoltageIncrement = 0.2;`
`113`	`114`
`114`		`- for (double voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)`
	`115`	`+ voltage = MinVoltage;`
	`116`	`+ for (; voltage <= MaxVoltage; voltage += VoltageIncrement)`
`115`	`117`	`{`
`116`	`118`	`SetVoltage(device, voltage);`
`117`	`119`
`118`	`120`	`if (CheckLinkState(device))`
`119`	`121`	`{`
`120`		`- SetVoltage(device, voltage + VoltageOffset);`
	`122`	`+ voltage += VoltageOffset;`
	`123`	`+ SetVoltage(device, voltage);`
`121`	`124`	`return CheckLinkState(device);`
`122`	`125`	`}`
`123`	`126`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,8 @@ public PortName Port`
`95`	`95`	`"the specified voltage to the headstage. Warning: this device requires 3.8V to 5.5V " +`
`96`	`96`	`"for proper operation. Higher voltages can damage the headstage.")]`
`97`	`97`	`[Category(ConfigurationCategory)]`
`98`		`- public double? PortVoltage`
	`98`	`+ [TypeConverter(typeof(PortVoltageConverter))]`
	`99`	`+ public AutoPortVoltage PortVoltage`
`99`	`100`	`{`
`100`	`101`	`get => PortControl.PortVoltage;`
`101`	`102`	`set => PortControl.PortVoltage = value;`
`@@ -110,19 +111,21 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()`
`110`	`111`
`111`	`112`	`class ConfigureHeadstageNric1384PortController : ConfigurePortController`
`112`	`113`	`{`
`113`		`- protected override bool ConfigurePortVoltage(DeviceContext device)`
	`114`	`+ protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)`
`114`	`115`	`{`
`115`	`116`	`const double MinVoltage = 3.8;`
`116`	`117`	`const double MaxVoltage = 5.5;`
`117`	`118`	`const double VoltageOffset = 0.7;`
`118`	`119`	`const double VoltageIncrement = 0.2;`
`119`	`120`
`120`		`- for (var voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)`
	`121`	`+ voltage = MinVoltage;`
	`122`	`+ for (; voltage <= MaxVoltage; voltage += VoltageIncrement)`
`121`	`123`	`{`
`122`	`124`	`SetPortVoltage(device, voltage);`
`123`	`125`	`if (base.CheckLinkState(device))`
`124`	`126`	`{`
`125`		`- SetPortVoltage(device, voltage + VoltageOffset);`
	`127`	`+ voltage += VoltageOffset;`
	`128`	`+ SetPortVoltage(device, voltage);`
`126`	`129`	`return CheckLinkState(device);`
`127`	`130`	`}`
`128`	`131`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,8 @@ public PortName Port`
`100`	`100`	`"to the headstage. Warning: this device requires 3.4V to 4.4V for proper operation." +`
`101`	`101`	`"Supplying higher voltages may result in damage to the headstage.")]`
`102`	`102`	`[Category(ConfigurationCategory)]`
`103`		`- public double? PortVoltage`
	`103`	`+ [TypeConverter(typeof(PortVoltageConverter))]`
	`104`	`+ public AutoPortVoltage PortVoltage`
`104`	`105`	`{`
`105`	`106`	`get => LinkController.PortVoltage;`
`106`	`107`	`set => LinkController.PortVoltage = value;`
`@@ -115,19 +116,21 @@ internal override IEnumerable<IDeviceConfiguration> GetDevices()`
`115`	`116`
`116`	`117`	`class ConfigureHeadstageRhs2116LinkController : ConfigurePortController`
`117`	`118`	`{`
`118`		`- protected override bool ConfigurePortVoltage(DeviceContext device)`
	`119`	`+ protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)`
`119`	`120`	`{`
`120`	`121`	`const double MinVoltage = 3.3;`
`121`	`122`	`const double MaxVoltage = 4.4;`
`122`	`123`	`const double VoltageOffset = 2.0;`
`123`	`124`	`const double VoltageIncrement = 0.2;`
`124`	`125`
`125`		`- for (var voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)`
	`126`	`+ voltage = MinVoltage;`
	`127`	`+ for (; voltage <= MaxVoltage; voltage += VoltageIncrement)`
`126`	`128`	`{`
`127`	`129`	`SetPortVoltage(device, voltage);`
`128`	`130`	`if (base.CheckLinkState(device))`
`129`	`131`	`{`
`130`		`- SetPortVoltage(device, voltage + VoltageOffset);`
	`132`	`+ voltage += VoltageOffset;`
	`133`	`+ SetPortVoltage(device, voltage);`
`131`	`134`	`return CheckLinkState(device);`
`132`	`135`	`}`
`133`	`136`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,20 +4,22 @@ namespace OpenEphys.Onix1`
`4`	`4`	`{`
`5`	`5`	`class ConfigureNeuropixelsV2ePortController : ConfigurePortController`
`6`	`6`	`{`
`7`		`- protected override bool ConfigurePortVoltage(DeviceContext device)`
	`7`	`+ protected override bool ConfigurePortVoltage(DeviceContext device, out double voltage)`
`8`	`8`	`{`
`9`	`9`	`const double MinVoltage = 3.3;`
`10`	`10`	`const double MaxVoltage = 5.5;`
`11`	`11`	`const double VoltageOffset = 1.0;`
`12`	`12`	`const double VoltageIncrement = 0.2;`
`13`	`13`
`14`		`- for (double voltage = MinVoltage; voltage <= MaxVoltage; voltage += VoltageIncrement)`
	`14`	`+ voltage = MinVoltage;`
	`15`	`+ for (; voltage <= MaxVoltage; voltage += VoltageIncrement)`
`15`	`16`	`{`
`16`	`17`	`SetVoltage(device, voltage);`
`17`	`18`
`18`	`19`	`if (CheckLinkState(device))`
`19`	`20`	`{`
`20`		`- SetVoltage(device, voltage + VoltageOffset);`
	`21`	`+ voltage += VoltageOffset;`
	`22`	`+ SetVoltage(device, voltage);`
`21`	`23`	`return CheckLinkState(device);`
`22`	`24`	`}`
`23`	`25`	`}`