436 lines
12 KiB
C#
436 lines
12 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Windows.Forms;
|
|
using System.Threading;
|
|
using System.Globalization;
|
|
|
|
namespace GenesisZeroFlow
|
|
{
|
|
|
|
public static class TaskOperations
|
|
{
|
|
|
|
public static Boolean[] GetResultTotal(Boolean[] enable, Task<Boolean> Task1, Task<Boolean> Task2, Task<Boolean> Task3, Task<Boolean> Task4, Task<Boolean> Task5, Task<Boolean> Task6, Task<Boolean> Task7, Task<Boolean> Task8, Task<Boolean> Task9, Task<Boolean> Task10)
|
|
{
|
|
#region Definitions and initializations
|
|
Boolean[] failed = new Boolean[Constants.NumberOfMeters];
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
failed[Meter] = false;
|
|
#endregion
|
|
#region Individual tasks
|
|
failed[Constants.Meter1] = GetResult(enable[Constants.Meter1], Task1);
|
|
failed[Constants.Meter2] = GetResult(enable[Constants.Meter2], Task2);
|
|
failed[Constants.Meter3] = GetResult(enable[Constants.Meter3], Task3);
|
|
failed[Constants.Meter4] = GetResult(enable[Constants.Meter4], Task4);
|
|
failed[Constants.Meter5] = GetResult(enable[Constants.Meter5], Task5);
|
|
failed[Constants.Meter6] = GetResult(enable[Constants.Meter6], Task6);
|
|
failed[Constants.Meter7] = GetResult(enable[Constants.Meter7], Task7);
|
|
failed[Constants.Meter8] = GetResult(enable[Constants.Meter8], Task8);
|
|
failed[Constants.Meter9] = GetResult(enable[Constants.Meter9], Task9);
|
|
failed[Constants.Meter10] = GetResult(enable[Constants.Meter10], Task10);
|
|
#endregion
|
|
|
|
return failed;
|
|
}
|
|
public static Boolean GetResult(Boolean enable, Task<Boolean> CurrentTask)
|
|
{
|
|
Boolean failed = false;
|
|
|
|
if (enable)
|
|
{
|
|
if (!TaskStatus.Equals(CurrentTask.Status, TaskStatus.Running))
|
|
{
|
|
if (TaskStatus.Equals(CurrentTask.Status, TaskStatus.RanToCompletion))
|
|
return CurrentTask.Result;
|
|
if (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Faulted))
|
|
return true;
|
|
if (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Canceled))
|
|
return true;
|
|
}
|
|
/*
|
|
else
|
|
{
|
|
if (CurrentTask.Status == TaskStatus.Created)
|
|
{
|
|
CurrentTask = Task.Run(() =>
|
|
{
|
|
return true;
|
|
});
|
|
while (CurrentTask.Status != TaskStatus.RanToCompletion) { };
|
|
CurrentTask.Dispose();
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
return failed;
|
|
}
|
|
public static void CheckAndDispose(ref Task<Boolean> CurrentTask)
|
|
{
|
|
if ((TaskStatus.Equals(CurrentTask.Status, TaskStatus.RanToCompletion)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Canceled)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Faulted)))
|
|
CurrentTask.Dispose();
|
|
}
|
|
public static void CheckAndDispose(Task<Boolean> CurrentTask)
|
|
{
|
|
if ((TaskStatus.Equals(CurrentTask.Status, TaskStatus.RanToCompletion)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Canceled)) || (TaskStatus.Equals(CurrentTask.Status, TaskStatus.Faulted)))
|
|
CurrentTask.Dispose();
|
|
}
|
|
public static Boolean WaitFor(Task<Boolean> task)
|
|
{
|
|
return WaitFor(true, task);
|
|
}
|
|
public static Boolean WaitFor(Boolean taskStarted, Task<Boolean> task)
|
|
{
|
|
#region CA1062
|
|
if (task == null)
|
|
return false;
|
|
#endregion
|
|
Boolean Completed = true;
|
|
|
|
if (taskStarted)
|
|
{
|
|
if ((TaskStatus.Equals(task.Status, TaskStatus.RanToCompletion)) || (TaskStatus.Equals(task.Status, TaskStatus.Faulted)) || (TaskStatus.Equals(task.Status, TaskStatus.Canceled)))
|
|
Completed = true;
|
|
else
|
|
Completed = false;
|
|
|
|
}
|
|
/*
|
|
else
|
|
{
|
|
task = Task.Run(() =>
|
|
{
|
|
return true;
|
|
});
|
|
|
|
while( task.Status != TaskStatus.RanToCompletion){ };
|
|
return true;
|
|
} */
|
|
|
|
return Completed;
|
|
}
|
|
}
|
|
|
|
public static partial class ArrayInit
|
|
{
|
|
public static UInt16[] Path(UInt16 value)
|
|
{
|
|
UInt16[] array = new UInt16[Constants.NumberOfPaths];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
array[Path] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Int32[] Path(Int32 value)
|
|
{
|
|
Int32[] array = new Int32[Constants.NumberOfPaths];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
array[Path] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Double[] Path(Double value)
|
|
{
|
|
Double[] array = new Double[Constants.NumberOfPaths];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
array[Path] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Boolean[] Path(Boolean value)
|
|
{
|
|
Boolean[] array = new Boolean[Constants.NumberOfPaths];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Path = Constants.PATH0; Path < Constants.NumberOfPaths; Path++)
|
|
array[Path] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static UInt16[] Thermo(UInt16 value)
|
|
{
|
|
UInt16[] array = new UInt16[Constants.NumberOfThermometers];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
array[Thermo] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Int32[] Thermo(Int32 value)
|
|
{
|
|
Int32[] array = new Int32[Constants.NumberOfThermometers];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
array[Thermo] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Double[] Thermo(Double value)
|
|
{
|
|
Double[] array = new Double[Constants.NumberOfThermometers];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Thermo = Constants.Thermo1; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
array[Thermo] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Boolean[] Thermo(Boolean value)
|
|
{
|
|
Boolean[] array = new Boolean[Constants.NumberOfThermometers];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Thermo = Constants.PATH0; Thermo < Constants.NumberOfThermometers; Thermo++)
|
|
array[Thermo] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static UInt16[] Meter(UInt16 value)
|
|
{
|
|
UInt16[] array = new UInt16[Constants.NumberOfMeters];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
array[Meter] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Int32[] Meter(Int32 value)
|
|
{
|
|
Int32[] array = new Int32[Constants.NumberOfMeters];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
array[Meter] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Double[] Meter(Double value)
|
|
{
|
|
Double[] array = new Double[Constants.NumberOfMeters];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
array[Meter] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
|
|
public static Boolean[] Meter(Boolean value)
|
|
{
|
|
Boolean[] array = new Boolean[Constants.NumberOfMeters];
|
|
|
|
try
|
|
{
|
|
for (UInt16 Meter = Constants.Meter1; Meter < Constants.NumberOfMeters; Meter++)
|
|
array[Meter] = value;
|
|
}
|
|
catch
|
|
{
|
|
|
|
}
|
|
|
|
return array;
|
|
}
|
|
}
|
|
|
|
public static partial class Misc
|
|
{
|
|
|
|
|
|
|
|
public static Double Minimum(Double valueA, Double valueB)
|
|
{
|
|
if (valueA < valueB)
|
|
return valueA;
|
|
else
|
|
return valueB;
|
|
}
|
|
|
|
public static Boolean[] Subarray(Boolean[] data, Int32 offset, Int32 width)
|
|
{
|
|
if (data.Count() < width + offset)
|
|
return null;
|
|
|
|
Boolean[] subdata = new Boolean[width];
|
|
|
|
for (UInt16 i = 0; i < width; i++)
|
|
subdata[i] = data[offset + i];
|
|
return subdata;
|
|
}
|
|
|
|
public static Byte[] Subarray(Byte[] data, Int32 offset, Int32 width)
|
|
{
|
|
if (data.Count() < width + offset)
|
|
return null;
|
|
|
|
Byte[] subdata = new Byte[width];
|
|
|
|
for (UInt16 i = 0; i < width; i++)
|
|
subdata[i] = data[offset + i];
|
|
return subdata;
|
|
}
|
|
|
|
public static void WaitForDebuging(Int32 value, CultureInfo culture)
|
|
{
|
|
for (Int32 i = value; i > 0; i--)
|
|
{
|
|
GenesisZeroFlow.Display.StatusLabel(i.ToString(culture));
|
|
WaitNSeconds(1);
|
|
}
|
|
}
|
|
|
|
public static Boolean OnlyDecimalInString(String data)
|
|
{
|
|
return (System.Text.RegularExpressions.Regex.IsMatch(data, @"^[0-9]+(\.[0-9]+)?$"));
|
|
}
|
|
|
|
public static Boolean OnlyHexInString(String data)
|
|
{
|
|
// For C-style hex notation (0xFF) you can use @"\A\b(0[xX])?[0-9a-fA-F]+\b\Z"
|
|
return System.Text.RegularExpressions.Regex.IsMatch(data, @"\A\b[0-9a-fA-F]+\b\Z");
|
|
}
|
|
|
|
|
|
public static void WaitCondition(Boolean condition)
|
|
{
|
|
if (condition)
|
|
Application.DoEvents();
|
|
}
|
|
|
|
|
|
public static void WaitNSeconds(Int32 seconds, bool fromGui = false)
|
|
{
|
|
fromGui = true;
|
|
if (fromGui)
|
|
{
|
|
if (seconds < 1) return;
|
|
TimeSpan ts = new TimeSpan();
|
|
DateTime _desired = DateTime.Now.AddSeconds(seconds);
|
|
while (DateTime.Now < _desired)
|
|
{
|
|
Application.DoEvents();
|
|
Thread.Sleep(100);
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Thread.Sleep(seconds * 1000);
|
|
}
|
|
}
|
|
|
|
|
|
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters")]
|
|
|
|
|
|
public static void WaitNMilliseconds(Int32 milliseconds, bool fromGui = false)
|
|
{
|
|
//if (fromGui)
|
|
//{
|
|
// if (milliseconds < 1) return;
|
|
// TimeSpan ts = new TimeSpan();
|
|
// DateTime _desired = DateTime.Now.AddMilliseconds(milliseconds);
|
|
// while (DateTime.Now < _desired)
|
|
// {
|
|
// Application.DoEvents();
|
|
// Thread.Sleep(1);
|
|
|
|
// }
|
|
//}
|
|
//else
|
|
//{
|
|
Thread.Sleep(milliseconds);
|
|
// }
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
} |