protected IProtocol protocol = null; // реализует работу с протоколом обмена Dsn
#endregion Fields
#region Methods
/// <summary>
/// Создать пакет для отправки в последовательный порт
/// </summary>
/// <param name="packet">Пакет из которого сделать пакет для блока отображения</param>
/// <param name="result">Данные конвертера</param>
/// <returns>Пакет для отправки на блок отображения</returns>
private byte[] GetComPacket(DisplayPacket packet, Float[] result)
{
Parameter[] parames = packet.Parameters;
if (parames != null)
{
byte[] data = GetData(parames, result);
if (data != null)
{
int size = 8 + data.Length;
byte[] com_packet = new byte[size];
com_packet[0] = 0x7e;
com_packet[1] = (byte)(0x80 | packet.Device);
com_packet[2] = (byte)(7 + data.Length);
com_packet[3] = 0x02;
com_packet[4] = 0x00;
com_packet[5] = (byte)data.Length;
Array.Copy(data, 0, com_packet, 6, data.Length);
SetCRC(com_packet);
return com_packet;
}
}
return null;
}
/// <summary>
/// Получить срез данных на текущий момент времени
/// </summary>
/// <returns>Текущий срез данных</returns>
public Float[] GetSlice()
{
bool blocked = false;
try
{
if (v_mutex.WaitOne(100, false))
{
blocked = true;
Float[] slice = new Float[slave.Length];
slave.CopyTo(slice, 0);
return slice;
}
else
return null;
}
catch (Exception ex)
{
if (OnError != null)
{
OnError(this, new ErrorArgs(ex.Message + "Stock -> GetSlice", ErrorType.Unknown));
}
}
finally
{
if (blocked) v_mutex.ReleaseMutex();
}
return null;
}
/// <summary>
/// Получить данный, которые содержаться в пакете
/// </summary>
/// <param name="parames">Параметры пакета</param>
/// <param name="result">Данные конвертера</param>
/// <returns>Массив данных пакета или null если данные не удалось извлечь</returns>
private byte[] GetData(Parameter[] parames, Float[] result)
{
int offset = 0;
byte[] data = new byte[256];
try
{
foreach (var parameter in parames)
{
byte[] tmp = null;
float current = GetValue(parameter.Position, result);
if (!float.IsNaN(current))
{
tmp = BitConverter.GetBytes((int)Math.Round(current));
}
else
tmp = new byte[4];
Array.Resize(ref tmp, parameter.Size);
if (parameter.IsLittleEndian) Array.Reverse(tmp);
Array.Copy(tmp, 0, data, offset, parameter.Size);
offset = offset + parameter.Size;
}
Array.Resize(ref data, offset);
return data;
}
catch
{
return null;
}
}
protected Mutex v_mutex; // синхронизирует доступ к извлеченным данным
#endregion Fields
#region Constructors
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
public Stock(Float[] buffer)
{
v_mutex = new Mutex();
c_mutex = new Mutex();
slave = buffer;
parameters = new List<Parameter>();
}
/// <summary>
/// Получить блоки для записи в файл
/// </summary>
/// <param name="parameters">Сохраняемые параметры</param>
/// <param name="result">Параметры конвертера</param>
/// <param name="time">Время вставляемое в блок данных</param>
/// <returns>Список блоков для записи в файл, или null если не удалось выделить ни один блок</returns>
private List<byte[]> GetBlocks(Parameter[] parameters, Float[] result, double time)
{
List<byte[]> blocks = new List<byte[]>();
int block_count = (int)(parameters.Length / 126);
int ostatok = (int)(parameters.Length % 126);
if (block_count == 0 && ostatok == 0) return null;
byte[] b_time = BitConverter.GetBytes(time);
int position = 0;
for (int i = 0; i < block_count; i++)
{
byte[] block = new byte[512];
Array.Copy(b_time, block, b_time.Length); // сохранили время
for (int j = 0; j < 126; j++)
{
if (position < parameters.Length)
{
if (parameters[position].IsActual)
{
float current = result[parameters[position++].Position].GetCurrentValue();
byte[] val = BitConverter.GetBytes(current);
Array.Copy(val, 0, block, (j * 4 + 8), 4);
}
}
else
return null;
}
blocks.Add(block);
}
if (ostatok > 0)
{
byte[] block_ost = new byte[512];
for (int i = 0; i < ostatok; i++)
{
Array.Copy(b_time, block_ost, b_time.Length); // сохранили время
if (position < result.Length)
{
float current = result[parameters[position++].Position].GetCurrentValue();
byte[] val = BitConverter.GetBytes(current);
Array.Copy(val, 0, block_ost, (i * 4 + 8), 4);
}
else
return null;
}
blocks.Add(block_ost);
}
return blocks;
}
private Stock stock = null; // реализует первичную обработку пакетов
#endregion Fields
#region Constructors
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
/// <param name="stocker">Парсер пакетов</param>
public Converter(Stock stocker, Float[] result)
{
parameters = result;
p_locker = new ReaderWriterLock();
f_locker = new ReaderWriterLock();
formuls = new List<Formula>();
stock = stocker;
state = State.Default;
t_mutex = new Mutex();
sync_call = new TimerCallback(TimerCallback);
}
private InsertToText t_inserter = null; // вывод значений во время калибровки
#endregion Fields
#region Constructors
public AddTransformationForm(Application _app)
{
app = _app;
app.Converter.OnComplete += new EventHandler(Converter_OnComplete);
InitializeComponent();
transformation = new Transformation();
transformation.OnInsert += new Transformation.TConditionEventHandle(transformation_OnInsert);
transformation.OnEdit += new Transformation.TConditionEventHandle(transformation_OnEdit);
transformation.OnRemove += new Transformation.TConditionEventHandle(transformation_OnRemove);
transformation.OnClear += new EventHandler(transformation_OnClear);
transformation.OnError += new Transformation.ErrorEventHandle(transformation_OnError);
transformation.OnExist += new Transformation.TConditionEventHandle(transformation_OnExist);
Transformation.TCondition t1 = new Transformation.TCondition();
Transformation.TCondition t2 = new Transformation.TCondition();
t1.Result = 0;
t1.Signal = 0;
t2.Result = 65535;
t2.Signal = 65535;
transformation.Insert(t1);
transformation.Insert(t2);
first = new Argument();
second = new Argument();
calibrationGraphic.CalculateScale();
t_inserter = new InsertToText(InserterText);
media = new Media();
media.Args[0].Index = 0;
media.Args[1].Index = 1;
med = new Float[2];
for (int i = 0; i < med.Length; i++)
{
med[i] = new Float();
}
}
/// <summary>
/// Вычислить параметры
/// </summary>
/// <param name="values">Данный из пакетов</param>
private void DoMacroses(Float[] values)
{
try
{
f_locker.AcquireWriterLock(100);
try
{
try
{
p_locker.AcquireWriterLock(100);
try
{
foreach (Formula formula in formuls)
{
if (formula.IsActual)
{
float result = formula.Macros.Calculate(values, parameters);
if (formula.Position > -1 && formula.Position < parameters.Length)
{
parameters[formula.Position].Value = result;
}
}
}
}
finally
{
p_locker.ReleaseWriterLock();
}
}
catch { }
}
finally
{
f_locker.ReleaseWriterLock();
}
}
catch (Exception ex)
{
if (OnError != null)
{
OnError(this, new ErrorArgs(ex.Message + "Converter->DoMacroses", ErrorType.NotFatal));
}
}
}
/// <summary>
/// Получить срез данных на текущий момент времени
/// </summary>
/// <returns>Текущий срез данных</returns>
public Float[] GetResults()
{
try
{
p_locker.AcquireReaderLock(300);
try
{
Float[] slice = new Float[parameters.Length];
parameters.CopyTo(slice, 0);
return(slice);
}
finally
{
p_locker.ReleaseReaderLock();
}
}
catch { }
return(null);
}
private Mutex t_mutex = null; // синхронизатор таймера
#endregion Fields
#region Constructors
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
protected Application()
{
signals = new Float[size];
results = new Float[size];
repository = new Repository();
repository.onError += new ApplicationErrorHandler(ErrorHandler);
for (int i = 0; i < size; i++)
{
signals[i] = new Float();
results[i] = new Float();
}
journal = Journal.CreateInstance();
p_locker = new ReaderWriterLock();
crc = TypeCRC.Cycled;
mode = ApplicationMode.Active;
serial = new Serial(repository);
serial.Secondary = new SecondaryPort(repository);
stock = new Stock(signals);
display = new DisplayUnit(repository);
converter = new Converter(stock, results);
devTcpOld = new TcpDevManager();
t_mutex = new Mutex();
timer = new Timer(TimerElapsed, null, Timeout.Infinite, period);
devTcpOld.Place = repository.InstancePlace();
saver = new Saver();
service = new Service();
}
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
protected Application()
{
signals = new Float[size];
results = new Float[size];
repository = new Repository();
repository.onError += new ApplicationErrorHandler(ErrorHandler);
for (int i = 0; i < size; i++)
{
signals[i] = new Float();
results[i] = new Float();
}
journal = Journal.CreateInstance();
p_locker = new ReaderWriterLock();
crc = TypeCRC.Cycled;
mode = ApplicationMode.Active;
serial = new Serial(repository);
serial.Secondary = new SecondaryPort(repository);
stock = new Stock(signals);
display = new DisplayUnit(repository);
converter = new Converter(stock, results);
devTcpOld = new TcpDevManager();
t_mutex = new Mutex();
timer = new Timer(TimerElapsed, null, Timeout.Infinite, period);
devTcpOld.Place = repository.InstancePlace();
saver = new Saver();
service = new Service();
}
/// <summary>
/// Получить срез данных на текущий момент времени
/// </summary>
/// <returns>Текущий срез данных</returns>
public Float[] GetSlice()
{
bool blocked = false;
try
{
if (v_mutex.WaitOne(100, false))
{
blocked = true;
Float[] slice = new Float[slave.Length];
slave.CopyTo(slice, 0);
return(slice);
}
else
{
return(null);
}
}
catch (Exception ex)
{
if (OnError != null)
{
OnError(this, new ErrorArgs(ex.Message + "Stock -> GetSlice", ErrorType.Unknown));
}
}
finally
{
if (blocked)
{
v_mutex.ReleaseMutex();
}
}
return(null);
}
/// <summary>
/// Получить значени из списка
/// </summary>
/// <param name="index">Позиция значения в списке</param>
/// <param name="values">Список значений</param>
/// <returns>Значение из списка</returns>
private float GetValue(int index, Float[] values)
{
if (index > -1 && index < values.Length)
{
return values[index].Value;
}
else
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireReaderLock(100);
try
{
if (signals != null && results != null)
{
float x = (arguments[0].Source == DataSource.Signals) ? GetValue(arguments[0].Index, signals) : GetValue(arguments[0].Index, results);
try
{
if (float.IsNaN(x) == false)
{
current += x;
}
else
current = 0.0f;
}
catch
{
current = 0.0f;
}
return current;
}
}
finally
{
locker.ReleaseReaderLock();
}
}
catch { }
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
bool blocked = false;
try
{
if (mutex.WaitOne(100, false))
{
blocked = true;
if (this.table.Count < 2) // таблица калибровки пуста
{
return float.NaN;
}
float x = (arguments[0].Source == DataSource.Signals) ? GetValue(arguments[0].Index, signals) : GetValue(arguments[0].Index, results);
if (float.IsNaN(x))
{
return float.NaN;
}
// Поиск интервала
double s = x;
int ind=0, LastIndex = this.table.Count - 1;
if (this.table[0].Signal > s)
{
ind = 1;
}
else
if (this.table[LastIndex].Signal < s)
{
ind = LastIndex;
}
else
{
for (int j = 1; j <= LastIndex; j++)
{
if ((this.table[j-1].Signal <= s) && (s <= this.table[j].Signal))
{
ind = j;
break;
}
}
}
// афинное преобразование сигнала в значение
double val = s * this.table[ind].Multy + this.table[ind].Shift;
return (float)val;
}
}
finally
{
if (blocked) mutex.ReleaseMutex();
}
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
if (slim.TryEnterWriteLock(300))
{
try
{
if (args != null)
{
current_value = 0.0f;
foreach (ArgumentPair pair in args)
{
if (pair != null)
{
float f_val = float.NaN;
float s_val = float.NaN;
if (pair.First.Index > -1 && pair.First.Index < results.Length)
{
f_val = results[pair.First.Index].Value;
}
if (pair.Second.Index > -1 && pair.Second.Index < results.Length)
{
s_val = results[pair.Second.Index].Value;
}
if (float.IsNaN(f_val) == false && float.IsNaN(s_val) == false)
{
if (f_val > s_val)
{
current_value = 1.0f;
break;
}
}
}
}
}
}
finally
{
slim.ExitWriteLock();
}
return current_value;
}
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireReaderLock(100);
try
{
if (signals != null && results != null)
{
float current = (arguments[0].Source == DataSource.Signals) ?
GetValue(arguments[0].Index, signals) : GetValue(arguments[0].Index, results);
if (float.IsNaN(current))
{
minimum = float.NaN;
return minimum;
}
if (float.IsNaN(minimum))
{
minimum = current;
return minimum;
}
minimum = (current < minimum) ? current : minimum;
return minimum;
}
}
finally
{
locker.ReleaseReaderLock();
}
}
catch { }
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireWriterLock(100);
try
{
if (signals != null && results != null)
{
float x = (arguments[0].Source == DataSource.Signals) ? GetValue(arguments[0].Index, signals) : GetValue(arguments[0].Index, results);
if (float.IsNaN(x) == false)
{
return (float)Math.Pow(10.0f, x);
}
else
return float.NaN;
}
}
finally
{
locker.ReleaseWriterLock();
}
}
catch { }
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireReaderLock(100);
try
{
if (signals != null && results != null)
{
Argument arg = argument[0];
if (arg != null)
{
switch (arg.Source)
{
case DataSource.Signals:
return GetValue(arg.Index, signals);
case DataSource.Results:
return GetValue(arg.Index, results);
default:
return float.NaN;
}
}
}
}
finally
{
locker.ReleaseReaderLock();
}
}
catch
{
}
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireReaderLock(100);
try
{
return constant;
}
finally
{
locker.ReleaseReaderLock();
}
}
catch
{
return float.NaN;
}
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireReaderLock(100);
try
{
if (signals != null && results != null)
{
P2 = (arguments[0].Source == DataSource.Signals) ? GetValue(arguments[0].Index, signals) : GetValue(arguments[0].Index, results);
if (float.IsNaN(P1))
{
P1 = P2;
}
P = P2 - P1;
return P;
}
}
finally
{
locker.ReleaseReaderLock();
}
return float.NaN;
}
catch
{
return float.NaN;
}
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
if (_slim.TryEnterReadLock(100))
{
try
{
if (createdScript == false)
{
if (script == null) script = InstanceScript(_script, _namespace, _classname, assembly.ToArray());
if (script != null)
{
current = script.Run(signals, results);
return current;
}
createdScript = true;
}
}
finally
{
_slim.ExitReadLock();
}
}
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireReaderLock(100);
try
{
if (signals != null && results != null)
{
float x = (arguments[0].Source == DataSource.Signals) ? GetValue(arguments[0].Index, signals) : GetValue(arguments[0].Index, results);
float y = (arguments[1].Source == DataSource.Signals) ? GetValue(arguments[1].Index, signals) : GetValue(arguments[1].Index, results);
try
{
if (y < 1 || float.IsNaN(y))
{
Summ = float.NaN;
current = float.NaN;
CurrentCount = 0;
CountOfMediaPoint = 0;
return current;
}
else
{
int j = (int)y;
if (CountOfMediaPoint != j)
{
CountOfMediaPoint = j;
Summ = float.NaN;
current = float.NaN;
CurrentCount = 0;
}
if (float.IsNaN(x))
{
Summ = float.NaN;
current = float.NaN;
CurrentCount = 0;
}
else
{
if (float.IsNaN(this.Summ))
{
CurrentCount = 1;
current = x;
Summ = x;
}
else
{
if (CurrentCount == CountOfMediaPoint)
{
Summ = Summ - current + x;
current = Summ / CountOfMediaPoint;
}
else
{
CurrentCount = CurrentCount + 1;
Summ = Summ + x;
current = Summ / CurrentCount;
}
}
}
}
}
catch
{
Summ = float.NaN;
current = float.NaN;
CurrentCount = 0;
}
return current;
}
}
finally
{
locker.ReleaseReaderLock();
}
}
catch { }
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
try
{
locker.AcquireWriterLock(100);
try
{
if (signals != null && results != null)
{
float a = (arguments[0].Source == DataSource.Signals) ? GetValue(arguments[0].Index, signals) : GetValue(arguments[0].Index, results);
float b = (arguments[1].Source == DataSource.Signals) ? GetValue(arguments[1].Index, signals) : GetValue(arguments[1].Index, results);
return (a * b);
}
else
return float.NaN;
}
finally
{
locker.ReleaseWriterLock();
}
}
catch { }
return float.NaN;
}
/// <summary>
/// Вычислить параметр
/// </summary>
/// <param name="signals">Значения поступившие с датчиков</param>
/// <param name="results">Значения являющиеся конечными данными</param>
/// <returns>Вычисленное значение</returns>
public float Calculate(Float[] signals, Float[] results)
{
return float.NaN;
}
/// <summary>
/// Получить срез данных на текущий момент времени
/// </summary>
/// <returns>Текущий срез данных</returns>
public Float[] GetResults()
{
try
{
p_locker.AcquireReaderLock(300);
try
{
Float[] slice = new Float[parameters.Length];
parameters.CopyTo(slice, 0);
return slice;
}
finally
{
p_locker.ReleaseReaderLock();
}
}
catch { }
return null;
}