HamBook – Diff between revs 46 and 54

Subversion Repositories:

?pathlinks?

Rev 46 – Details – Blame – Last modification – View Log

-using HamBook.Radios.Generic;
-using HamBook.Radios.Generic.CAT;
-using System;
-using System.Collections.Generic;
+using System.Text.RegularExpressions;
-using System.Drawing;
+using System.Threading;
-using System.IO.Ports;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
-using static HamBook.Radios.Yaesu.FT_891.Constants;
+using HamBook.Radios.Generic;
 using RJCP.IO.Ports;
-using System.Threading;
-using System.Diagnostics;
+using static HamBook.Radios.Yaesu.FT_891.Constants;
 namespace HamBook.Radios.Yaesu.FT_891.CAT
+{
     [Radio("Yaesu FT-891")]
-    public class PS : HamBook.Radios.Generic.CAT.PS
+    public class Ps : Generic.CAT.Ps
     {
-        private readonly Regex readRegex;
-        public override CatLength CatLength => new CatLength { Set = 4, Answer = 4, Read = 3 };
+        private readonly Regex _readRegex;
-        public PS(SerialPortStream serialPort) : base(serialPort)
+        public Ps(SerialPortStream serialPort) : base(serialPort)
+        {
+            _readRegex = new Regex($"^{Name}(?<state>[01]){Eot}$", RegexOptions.Compiled);
+        }
             readRegex = new Regex($"^{Name}(?<state>[01]){Constants.EOT}$", RegexOptions.Compiled);
         public override CatLength CatLength => new CatLength { Set = 4, Answer = 4, Read = 3 };
         public override async Task<bool> SetAsync(PowerState state, CancellationToken cancellationToken)
+        {
             SerialPort.Write(new byte[1] { 0 }, 0, 1);
             SerialPort.Read(new byte[2] { 0, 0 }, 0, 2);
             var taskCompletionSource = new TaskCompletionSource<bool>();
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Delay(POWER_ON_DELAY).ContinueWith(async task1 =>
+            Task.Delay(PowerOnDelay).ContinueWith(async task1 =>
             {
                 byte[] payload = null;
-                switch(state)
-                {
-                    case PowerState.ON:
+                switch (state)
-                        payload = Constants.Encoding.GetBytes($"{Name}1{Constants.EOT}");
                         await SerialPort.WriteAsync(payload, 0, payload.Length);
-                        Task.Delay(TIME_TO_WARM).ContinueWith(task2 =>
+                    case PowerState.ON:
-                        {
+                        payload = Encoding.GetBytes($"{Name}1{Eot}");
-                            taskCompletionSource.TrySetResult(true);
+                        await SerialPort.WriteAsync(payload, 0, payload.Length);
-                        });
+                        Task.Delay(TimeToWarm).ContinueWith(task2 => { taskCompletionSource.TrySetResult(true); });
                         return;
+                    case PowerState.OFF:
-                    case PowerState.OFF:
+                        payload = Encoding.GetBytes($"{Name}0{Eot}");
-                        payload = Constants.Encoding.GetBytes($"{Name}0{Constants.EOT}");
+                        await SerialPort.WriteAsync(payload, 0, payload.Length);
-                        await SerialPort.WriteAsync(payload, 0, payload.Length);
+                        break;
                         break;
             SerialPort.Read(new byte[2] { 0, 0 }, 0, 2);
             var taskCompletionSource = new TaskCompletionSource<int>();
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Delay(POWER_ON_DELAY).ContinueWith(async _ =>
+            Task.Delay(PowerOnDelay).ContinueWith(async _ =>
+            {
-                var payload = Constants.Encoding.GetBytes($"{Name}{Constants.EOT}");
+                var payload = Encoding.GetBytes($"{Name}{Eot}");
                 await SerialPort.WriteAsync(payload, 0, payload.Length, cancellationToken);
                 var buffer = new byte[CatLength.Answer];
                 if (await SerialPort.ReadAsync(buffer, 0, CatLength.Answer, cancellationToken) != CatLength.Answer)
+                {
-                {
+                    taskCompletionSource.TrySetResult(-1);
-                    taskCompletionSource.TrySetResult(-1);
                     throw new UnexpectedRadioResponseException(Name, buffer);
                     throw new UnexpectedRadioResponseException(Name, buffer);
-                var answer = Constants.Encoding.GetString(buffer);
+                var answer = Encoding.GetString(buffer);
-                var match = readRegex.Match(answer);
+                var match = _readRegex.Match(answer);
                 if (!match.Success)
+                {
-                    taskCompletionSource.TrySetResult(-1);
                     taskCompletionSource.TrySetResult(-1);
                     throw new UnmatchedRadioResponseException(Name, answer);
                     throw new UnmatchedRadioResponseException(Name, answer);
+                }
                 var state = int.Parse(match.Result("${state}"));
-                taskCompletionSource.TrySetResult(state);
+                var state = int.Parse(match.Result("${state}"));
                 taskCompletionSource.TrySetResult(state);
             });
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
             var onoff = await taskCompletionSource.Task;
-            switch(onoff)
+            switch (onoff)
+            {
                 case 1:
                     return PowerState.ON;
                 case 0: