//----------------------------------------------------------------------------
public void Read_IR_TypeOfDevice(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error, Byte addressSlave, out TYPE_NGK_DEVICE typeOfDevice)
{
Modbus.OSIModel.Message.Result result;
UInt16[] registers;
if (host == null)
{
typeOfDevice = TYPE_NGK_DEVICE.UNKNOWN_DEVICE;
error = new OperationResult(OPERATION_RESULT.CONNECTION_ERROR,
"Подключение к сети не создано");
}
else
{
if (host.DataLinkObject.IsOpen())
{
result = host.ReadInputRegisters(addressSlave,
BI_ADDRESSES_OF_INPUTREGISTERS.TypeOfDevice,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
try
{
typeOfDevice =
(TYPE_NGK_DEVICE)Enum.Parse(typeof(TYPE_NGK_DEVICE),
registers[0].ToString());
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
catch
{
typeOfDevice = TYPE_NGK_DEVICE.UNKNOWN_DEVICE;
error = new OperationResult(OPERATION_RESULT.UNKNOWN_DEVICE,
String.Format(
"Устройство вернуло код неизвестного типа устройства: {0}", registers[0].ToString()));
}
}
else
{
typeOfDevice = TYPE_NGK_DEVICE.UNKNOWN_DEVICE;
error = new OperationResult(OPERATION_RESULT.FAILURE,
result.Description);
}
}
else
{
typeOfDevice = TYPE_NGK_DEVICE.UNKNOWN_DEVICE;
error = new OperationResult(OPERATION_RESULT.CONNECTION_ERROR,
"Соeдинение создано, но не открыто");
}
}
return;
}
//----------------------------------------------------------------------------
public void Write_HR_MeasuringVoltagePeriod(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
//throw new InvalidOperationException("Операция не применима к версии БИ(У)-01");
error = new OperationResult(OPERATION_RESULT.INVALID_OPERATION,
"Операция не применима к версии БИ(У)-01");
}
//----------------------------------------------------------------------------
public void Read_IR_InternalTemperatureSensor(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
//throw new InvalidOperationException("Операция неподдреживается в БИ(У)-00");
error = new OperationResult(OPERATION_RESULT.INVALID_OPERATION,
"Операция неподдреживается в БИ(У)-00");
//Modbus.OSIModel.Message.Result result;
////String msg;
//UInt16[] registers;
//result = host.ReadInputRegisters(_AddressSlave,
// BI_ADDRESSES_OF_INPUTREGISTERS.InternalTemperatureSensor,
// 1, out registers);
//if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
//{
// this.InternalTemperatureSensor =
// (Int16)(ToValue(registers[0]));
// error = new OperationResult(true, String.Empty);
//}
//else
//{
// error = new OperationResult(false, result.Description);
//}
return;
}
//----------------------------------------------------------------------------
public void Read_IR_SerialNumber(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
//String msg;
UInt16[] registers;
result = host.ReadInputRegisters(AddressSlave,
BI_ADDRESSES_OF_INPUTREGISTERS.SerialNumber,
3, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
UInt64 serialNumber;
serialNumber = 0;
serialNumber = registers[0]; // Upper
serialNumber |= (serialNumber << 16);
serialNumber |= registers[1]; // High
serialNumber |= (serialNumber << 16);
serialNumber |= registers[2]; // Low
this.SerialNumber = serialNumber;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Read_IR_TypeOfDevice(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error, out TYPE_NGK_DEVICE typeOfDevice)
{
Modbus.OSIModel.Message.Result result;
//String msg;
UInt16[] registers;
result = host.ReadInputRegisters(AddressSlave,
BI_ADDRESSES_OF_INPUTREGISTERS.TypeOfDevice,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
try
{
typeOfDevice =
(TYPE_NGK_DEVICE)Enum.Parse(typeof(TYPE_NGK_DEVICE),
registers[0].ToString());
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
catch
{
typeOfDevice = TYPE_NGK_DEVICE.UNKNOWN_DEVICE;
error = new OperationResult(OPERATION_RESULT.UNKNOWN_DEVICE, String.Format(
"Устройство вернуло код неизвестного типа устройства: {0}", registers[0].ToString()));
}
}
else
{
typeOfDevice = TYPE_NGK_DEVICE.UNKNOWN_DEVICE;
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Write_CL_AcCurrentRefereceElectrodeEn(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
String msg;
Modbus.State coil;
coil = Modbus.Convert.ToState(this.AcCurrentRefereceElectrodeEn);
result = host.WriteSingleCoil(_AddressSlave,
BI_ADDRESSES_OF_COILS.AcCurrentRefereceElectrodeEn, ref coil);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
// Проверяем записанные данные
if (this.AcCurrentRefereceElectrodeEn !=
Modbus.Convert.ToBoolean(coil))
{
msg = String.Format(
"Параметр записан не верно: должно быть {0}, устройство вернуло {1}",
this.AcCurrentRefereceElectrodeEn, coil);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Read_HR_DateTime(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error, out DateTime dataTime)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
DateTime unixStartTime;
UInt32 totalSeconds;
String msg;
dataTime = DateTime.Now;
result = host.ReadHoldingRegisters(_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.DateTime,
2, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
if (registers.Length != 2)
{
msg = String.Format(
"Ответ БИ содержит количесво прочитанных регистров {0}, должно быть 2",
registers.Length);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
// Читать время необходимо из входного регистра. Через регистр
// хранения время только записывается в устройство БИ
//unixStartTime = DateTime.Parse("01/01/1970 00:00:00",
// new System.Globalization.CultureInfo("ru-Ru", false));
unixStartTime = new System.DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
totalSeconds = 0;
totalSeconds = registers[0]; // Hi_byte
totalSeconds = (totalSeconds << 16);
totalSeconds |= registers[1]; // Lo_byte
dataTime = unixStartTime.AddSeconds(totalSeconds);
this._DateTime = dataTime;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Read_HR_CurrentShuntValue(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
CurrentShuntValues shunt;
result = host.ReadHoldingRegisters(_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.CurrentShuntValue,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
try
{
shunt =
(CurrentShuntValues)Enum.ToObject(typeof(CurrentShuntValues), registers[0]);
this.CurrentShuntValue = shunt;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
catch (Exception ex)
{
error = new OperationResult(OPERATION_RESULT.FAILURE, ex.Message);
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
/// <summary>
/// Проверяет иницилизировано устройство или нет. Т.е. установлен
/// серийный номер и следовательно не доступен регистр хранения
/// для записи серийного номера
/// </summary>
/// <param name="deviceInit">
/// Если - true, то устройство инициализировано</param>
/// <param name="error">Статус выполения операции по сети</param>
public void VerifyInitDevice(
out Boolean deviceInit,
out OperationResult error)
{
Boolean init;
OperationResult result;
this.LockGUI();
// Читаем регистр хранения, если он не доступен, то устройство
// инициализировано
_MeasuringDevice.Read_HR_VerifyInitDevice(
ref _Host, out init, out result);
error = result;
deviceInit = init;
this.UnLockGUI();
return;
}
//----------------------------------------------------------------------------
/// <summary>
/// Читает визитную карточку устройства
/// </summary>
/// <param name="result">Результат выполения операции чтения визитной карточки устройства</param>
/// <param name="deviceInfo">Визитная карточка устройства</param>
public void ReadCallingCard(
out OperationResult result,
out CallingCard deviceInfo)
{
this.LockGUI();
this.Cursor = Cursors.WaitCursor;
NGK.MeasuringDeviceTech.Classes.MeasuringDevice.CallingCardOfDevice.Read_IRs_CallingCard(
ref _Host, out result, 1, out deviceInfo);
this.Cursor = Cursors.Default;
this.UnLockGUI();
return;
}
//----------------------------------------------------------------------------
/// <summary>
/// Читает версию аппаратного обеспечения подключенного устройства,
/// без созданного виртуального.
/// </summary>
/// <param name="host"></param>
/// <param name="error"></param>
/// <param name="addressSlave"></param>
/// <param name="version"></param>
public void Read_IR_HardWareVersion(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error, Byte addressSlave, out float version)
{
Modbus.OSIModel.Message.Result result;
//String msg;
UInt16[] registers;
this.LockGUI();
if (host == null)
{
version = 0;
error = new OperationResult(OPERATION_RESULT.CONNECTION_ERROR,
"Подключение к сети не создано");
}
else
{
if (host.DataLinkObject.IsOpen())
{
result = host.ReadInputRegisters(addressSlave,
BI_ADDRESSES_OF_INPUTREGISTERS.VersionHardware,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
version = ((float)registers[0]) / 100;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
version = 0;
error = new OperationResult(OPERATION_RESULT.FAILURE,
result.Description);
}
}
else
{
version = 0;
error = new OperationResult(OPERATION_RESULT.CONNECTION_ERROR,
"Содениение создано, но порт закрыт");
}
}
this.UnLockGUI();
return;
}
//------------------------------------------------------------------------------------------------------
/// <summary>
/// Читает визитную карточку NGK-устройства
/// </summary>
/// <param name="host"></param>
/// <param name="error"></param>
/// <param name="addressSlave"></param>
/// <param name="card"></param>
public static void Read_IRs_CallingCard(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error,
Byte addressSlave, out CallingCard card)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
String msg;
UInt16 startAddress = 0x0000; // Адрес начального входного регистра визитной карточки
UInt16 length = 7;
result = host.ReadInputRegisters(addressSlave,
startAddress, length, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
if (registers.Length != 7)
{
msg = String.Format(
"Ответ БИ содержит количесво прочитанных регистров {0}, должно быть 7",
registers.Length);
card = null;
error = new OperationResult(OPERATION_RESULT.FAILURE, msg);
}
else
{
// Рассчитываем контрольную сумму.
List<Byte> arr = new List<Byte>();
// Получаем массив байт (без регистра с CRC16)
for (int i = 0; i < (registers.Length - 1); i++)
{
arr.AddRange(Modbus.Convert.ConvertToBytes(registers[i]));
}
// Рассчитываем CRC16 и сравниваем с прочитанным
Byte[] crc16calc_b = Modbus.OSIModel.DataLinkLayer.CRC16.CalcCRC16(arr.ToArray());
UInt16 crc16calc = 0;
crc16calc = crc16calc_b[1]; // Hi_byte crc16
crc16calc = (UInt16)(crc16calc << 8);
crc16calc |= crc16calc_b[0]; // Lo_byte crc16
// Проверяем контрольную сумму (прочитанную и рассчитаную)
if (registers[registers.Length - 1] == crc16calc)
{
// Контрольная сумма сошлась, получаем данные визтной карты
card = new CallingCard();
// Получаем тип устройства
try
{
card.TypeOfDevice = (TYPE_NGK_DEVICE)Enum.Parse(typeof(TYPE_NGK_DEVICE), registers[0].ToString());
}
catch
{
msg = String.Format(
"Неизвестный тип устройства, код типа устройства: {0}",
registers[0]);
error = new OperationResult(OPERATION_RESULT.FAILURE, msg);
return;
}
// Получаем версию ПО
card.SofwareVersion = ((float)registers[1]) / 100;
// Получаем версию Аппаратуры
card.HardwareVersion = ((float)registers[2]) / 100;
// Получаем серийный номер
card.SerialNumber = 0;
card.SerialNumber = registers[3];
card.SerialNumber |= (card.SerialNumber << 16);
card.SerialNumber |= registers[4];
card.SerialNumber |= (card.SerialNumber << 16);
card.SerialNumber |= registers[5];
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
msg =
"Конрольная сумма визитной краточки не совпала с рассчётной";
card = null;
error = new OperationResult(OPERATION_RESULT.FAILURE, msg);
}
}
}
else
{
// При выполнени чтения устройства возникли проблемы...
card = null;
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
/// <summary>
/// Читает серийный номер в устройство БИ при первоначальной инициализации
/// </summary>
/// <param name="host">Modbus master устройство</param>
/// <param name="error">Результат выполнеия операции</param>
/// <param name="addressSlave">Адрес подчинённого устройство</param>
/// <param name="serialNumber">Серийный номер для записи в устройство</param>
public static void Read_HR_SerialNumber(ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error, Byte addressSlave, out UInt64 serialNumber)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
String msg;
serialNumber = 0;
result = host.ReadHoldingRegisters(addressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.SerialNumber,
3, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
if (registers.Length != 3)
{
msg = String.Format(
"Ответ БИ содержит количесво прочитанных регистров {0}, должно быть 3",
registers.Length);
error = new OperationResult(OPERATION_RESULT.FAILURE, msg);
}
else
{
serialNumber = 0;
serialNumber = registers[2];
serialNumber |= (serialNumber << 16);
serialNumber |= registers[1];
serialNumber |= (serialNumber << 16);
serialNumber |= registers[0];
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, String.Empty);
}
return;
}
//------------------------------------------------------------------------------------------------------
/// <summary>
/// Записывает серийный номер в устройство БИ при первоначальной инициализации
/// </summary>
/// <param name="host">Modbus master устройство</param>
/// <param name="error">Результат выполнеия операции</param>
/// <param name="addressSlave">Адрес подчинённого устройство</param>
/// <param name="serialNumber">Серийный номер для записи в устройство</param>
public static void Write_HR_SerialNumber(ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error, Byte addressSlave ,UInt64 serialNumber)
{
// Записываем новое значение в устройство
Modbus.OSIModel.Message.Result result;
UInt16[] registers = new ushort[3] { 0, 0, 0 };
String msg;
//this.Cursor = Cursors.WaitCursor;
unchecked
{
registers[0] = (UInt16)serialNumber;
registers[1] = (UInt16)(serialNumber >> 16);
registers[2] = (UInt16)(serialNumber >> 32);
}
result = host.WriteMultipleRegisters(
addressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.SerialNumber,
registers);
if (result.Error != Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
else
{
// Проверяем правильно ли записался параметр
// Читаем записанный параметр
result = host.ReadHoldingRegisters(addressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.SerialNumber,
3, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
if (registers.Length != 3)
{
msg = String.Format(
"Ответ БИ содержит количество прочитанных регистров {0}, должно быть 3",
registers.Length);
error = new OperationResult(OPERATION_RESULT.FAILURE, msg);
}
else
{
UInt64 number_wr;
number_wr = 0;
number_wr = registers[2];
number_wr |= (number_wr << 16);
number_wr |= registers[1];
number_wr |= (number_wr << 16);
number_wr |= registers[0];
if (number_wr != serialNumber)
{
msg = String.Format(
"Значение записанного прараметра {0} не совподает с прочитанным {1}",
serialNumber, number_wr);
error = new OperationResult(OPERATION_RESULT.FAILURE, msg);
}
else
{
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
}
return;
}
//----------------------------------------------------------------------------
public void Read_HR_PollingPeriodChannel2(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
result = host.ReadHoldingRegisters(_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.PollingPeriodChannel2_4_20,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
try
{
this.PollingPeriodChannel2 = (UInt32)(registers[0] * 10);
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
catch (Exception ex)
{
error = new OperationResult(OPERATION_RESULT.FAILURE, ex.Message);
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Write_HR_CurrentShuntValue(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
// Записываем новое значение в устройство
Modbus.OSIModel.Message.Result result;
UInt16 value = (UInt16)this.CurrentShuntValue;
String msg;
result = host.WriteSingleRegister(
_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.CurrentShuntValue,
ref value);
if (result.Error != Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
else
{
// Читаем записаное и сверяем результаты
if ((UInt16)this.CurrentShuntValue != value)
{
msg = String.Format(
"Значение записанного прараметра {0} не совподает с прочитанным {1}",
this.CurrentShuntValue, value);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
}
return;
}
//------------------------------------------------------------------------------------------------------
#region NetworksCommands
//------------------------------------------------------------------------------------------------------
/// <summary>
/// Проверяет инициализировано устройство или нет.
/// </summary>
/// <param name="host">Master-устройство</param>
/// <param name="init">TRUE-устройство иницилизировано</param>
/// <param name="error">Результат выполнения операции</param>
public void Read_HR_VerifyInitDevice(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out Boolean init,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
UInt16[] registers;
result = host.ReadHoldingRegisters(
_AddressSlave, BI_ADDRESSES_OF_HOLDINGREGISTERS.SerialNumber,
3, out registers);
switch (result.Error)
{
case Modbus.OSIModel.ApplicationLayer.Error.NoError:
{
// Регистры доступны и значит устройство не инициализировано
init = false;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
break;
}
case Modbus.OSIModel.ApplicationLayer.Error.IllegalDataAddress:
{
// Регистры не доступны значит устройство инициализировано
init = true;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
break;
}
default:
{
init = false;
String msg = String.Format(
"Ошибка выполнения чтения устройства. Устройство венуло ошибку: {0}",
result.Description);
error = new OperationResult(OPERATION_RESULT.FAILURE, msg);
break;
}
}
}
//----------------------------------------------------------------------------
public void Write_HR_DateTime(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
// Записываем новое значение в устройство
Modbus.OSIModel.Message.Result result;
UInt16[] registers = new ushort[2] { 0, 0 };
DateTime unixStartTime;
DateTime dt = DateTime.Now;
UInt32 totalSeconds;
//String msg;
TimeSpan ts;
//unixStartTime = DateTime.Parse("01/01/1970 00:00:00",
// new System.Globalization.CultureInfo("ru-Ru", false));
unixStartTime = new System.DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
ts = (DateTime.Now.ToUniversalTime()).Subtract(unixStartTime);
totalSeconds = Convert.ToUInt32(ts.TotalSeconds);
unchecked
{
registers[0] = (UInt16)(totalSeconds >> 16); // Hi_byte
registers[1] = (UInt16)(totalSeconds); // Lo byte
}
result = host.WriteMultipleRegisters(
_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.DateTime,
registers);
if (result.Error != Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
else
{
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
// Проверку записанное осуществить невозможно, по причине хода часов!!!
return;
}
//------------------------------------------------------------------------------------------------------
/// <summary>
/// Читаем серийный номер устройства. Если данный регистр не доступен,
/// то устройство инициализировано.
/// В противном случае, необходимо записать серийный номер.
/// </summary>
/// <param name="host"></param>
/// <param name="serialNumber"></param>
/// <param name="error"></param>
public void Read_HR_SerialNumber(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out UInt64 serialNumber,
out OperationResult error)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
result = host.ReadHoldingRegisters(_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.SerialNumber,
3, out registers);
switch (result.Error)
{
case Modbus.OSIModel.ApplicationLayer.Error.NoError:
{
if (registers.Length == 3)
{
serialNumber = 0;
serialNumber = registers[0];
serialNumber = (serialNumber << 16);
serialNumber |= registers[1];
serialNumber = (serialNumber << 16);
serialNumber |= registers[2];
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
serialNumber = 0;
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER,
String.Format(
"Устройство вернуло неверные данные. Количество регистров {0}, а должно быть 3",
registers.Length));
}
break;
}
case Modbus.OSIModel.ApplicationLayer.Error.IllegalDataAddress:
{
serialNumber = 0;
error = new OperationResult(OPERATION_RESULT.IllegalDataAddress, result.Description);
break;
}
default:
{
serialNumber = 0;
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
break;
}
}
return;
}
//----------------------------------------------------------------------------
public void Read_CL_AcCurrentRefereceElectrodeEn(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
//String msg;
Modbus.State[] coils;
result = host.ReadCoils(_AddressSlave,
BI_ADDRESSES_OF_COILS.AcCurrentRefereceElectrodeEn, 1, out coils);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
this.AcCurrentRefereceElectrodeEn =
Modbus.Convert.ToBoolean(coils[0]);
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
}
//------------------------------------------------------------------------------------------------------
public void Write_HR_SerialNumber(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
UInt64 serialNumber,
out OperationResult error)
{
// Записываем новое значение в устройство
Modbus.OSIModel.Message.Result result;
UInt64 sn;
UInt16[] value;
//String msg;
value = new ushort[3];
value[2] = (UInt16)serialNumber; // Low
value[1] = (UInt16)(serialNumber >> 16); // High
value[0] = (UInt16)(serialNumber >> 32); // Upper
result = host.WriteMultipleRegisters(
_AddressSlave, BI_ADDRESSES_OF_HOLDINGREGISTERS.SerialNumber,
value);
if (result.Error != Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
// При операции записи произошла ошибка
error = new OperationResult(OPERATION_RESULT.FAILURE,
result.Description);
}
else
{
// После записи данный регистр становиться не доступен
// Проверяем записанные данные
this.Read_HR_SerialNumber(ref host,
out sn, out error);
switch (error.Result)
{
case OPERATION_RESULT.IllegalDataAddress:
{
// // Чтение выполено успешно, проверяем данные
// if (sn == serialNumber)
// {
// error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
// }
// else
// {
// msg = String.Format(
// "Ошибка записи серийного номера устройства. Не совпал записанное {0} и прочитанное значение {1}",
// serialNumber, sn);
// error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
// }
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
break;
}
case OPERATION_RESULT.OK:
{
// При выполнении операции чтения произошла ошибка
error = new OperationResult(OPERATION_RESULT.FAILURE,
"Ошибка: После инициализации устройсвта регистр хранения остался доступен");
break;
}
default:
{
error = new OperationResult(OPERATION_RESULT.FAILURE, error.Message);
break;
}
}
}
return;
}
//----------------------------------------------------------------------------
public void Read_DI_CorrosionSensor3(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
//String msg;
Modbus.State[] discreteInputs;
result = host.ReadDiscreteInputs(_AddressSlave,
BI_ADDRESSES_OF_DISCRETESINPUTS.CorrosionSensor3,
1, out discreteInputs);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
this.CorrosionSensor3 =
Modbus.Convert.ToBoolean(discreteInputs[0]);
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Read_HR_MeasuringPeriod(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
UInt32 period = 0;
String msg;
result = host.ReadHoldingRegisters(_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.MeasuringPeriod,
2, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
if (registers.Length != 2)
{
msg = String.Format(
"Ответ БИ содержит количесво прочитанных регистров {0}, должно быть 2",
registers.Length);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
period |= registers[0]; // high
period = period << 16;
period |= registers[1]; // low
try
{
this.MeasuringPeriod = period;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
catch (Exception ex)
{
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, ex.Message);
}
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Read_IR_HardWareVersion(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
//String msg;
UInt16[] registers;
result = host.ReadInputRegisters(AddressSlave,
BI_ADDRESSES_OF_INPUTREGISTERS.VersionHardware,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
this.HardwareVersion = ((float)registers[0]) / 100;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Write_HR_MeasuringVoltagePeriod(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
ushort[] registers;
Modbus.OSIModel.Message.Result result;
String msg;
UInt16 period = this._MeasuringVoltagePeriod;
registers = new ushort[] { period };
result = host.WriteMultipleRegisters(_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.MeasuringSupplyVoltagePeriod,
registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
if (registers.Length != 1)
{
msg = String.Format(
"Ответ БИ содержит количесво прочитанных регистров {0}, должен быть 1",
registers.Length);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
// Проверяем записанное и прочитанное
result = host.ReadHoldingRegisters(_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.MeasuringSupplyVoltagePeriod,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
if (registers.Length != 1)
{
msg = String.Format(
"Ответ БИ содержит количесво прочитанных регистров {0}, должен быть 1",
registers.Length);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
period = registers[0];
if (this.MeasuringVoltagePeriod != period)
{
msg = String.Format(
"Значение записанного прараметра {0} не совподает с прочитанным {1}",
this.MeasuringPeriod, period);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
}
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Read_IR_BattaryVoltage(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
//String msg;
UInt16[] registers;
result = host.ReadInputRegisters(_AddressSlave,
BI_ADDRESSES_OF_INPUTREGISTERS.BattaryVoltage,
1, out registers);
if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
this.BattaryVoltage =
(float)(ToValue(registers[0]) * 0.01);
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
else
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
return;
}
//----------------------------------------------------------------------------
public void Write_HR_PollingPeriodChannel2(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
// Записываем новое значение в устройство
Modbus.OSIModel.Message.Result result;
UInt16 value = (UInt16)(this.PollingPeriodChannel2 / 10);
String msg;
result = host.WriteSingleRegister(
_AddressSlave,
BI_ADDRESSES_OF_HOLDINGREGISTERS.PollingPeriodChannel2_4_20,
ref value);
if (result.Error != Modbus.OSIModel.ApplicationLayer.Error.NoError)
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
}
else
{
if ((value * 10) != this.PollingPeriodChannel2)
{
msg = String.Format(
"Параметр записан не верно: должно быть {0}, устройство вернуло {1}",
this.PollingPeriodChannel2, value);
error = new OperationResult(OPERATION_RESULT.INCORRECT_ANSWER, msg);
}
else
{
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
}
}
return;
}
//----------------------------------------------------------------------------
public void Read_IR_ReferenceElectrodeACCurrent(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
Modbus.OSIModel.Message.Result result;
//String msg;
UInt16[] registers;
result = host.ReadInputRegisters(_AddressSlave,
BI_ADDRESSES_OF_INPUTREGISTERS.ReferenceElectrodeAcCurrent,
1, out registers);
//if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
//{
// this._ReferenceElectrodeAcСurrent =
// (float)((registers[0]) * 0.01);
// error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
//}
//else
//{
// error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
//}
switch (result.Error)
{
case Modbus.OSIModel.ApplicationLayer.Error.NoError:
{
this._ReferenceElectrodeAcСurrent = (float)((registers[0]) * 0.01);
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
break;
}
case Modbus.OSIModel.ApplicationLayer.Error.IllegalDataAddress:
{
// Если возвращается исключение 0x2 (регистр не доступен для чтения)
// это является нормальной ситуацией.
// См. протокол: При чтении Input Register, определённого в Coil как
// неактивный канал измерения возвращать исключение 0х02.
this._ReferenceElectrodeAcСurrent = 0;
error = new OperationResult(OPERATION_RESULT.OK, String.Empty);
break;
}
default:
{
error = new OperationResult(OPERATION_RESULT.FAILURE, result.Description);
break;
}
}
return;
}
//----------------------------------------------------------------------------
public void Read_HR_MeasuringVoltagePeriod(
ref Modbus.OSIModel.ApplicationLayer.Master.Device host,
out OperationResult error)
{
error = new OperationResult(OPERATION_RESULT.INVALID_OPERATION,
"Операция не применима к версии БИ(У)-01");
//throw new InvalidOperationException("Операция не применима к версии БИ(У)-01");
//ushort[] registers;
//Modbus.OSIModel.Message.Result result;
//UInt16 period = 0;
//result = host.ReadHoldingRegisters(_AddressSlave,
// BI_ADDRESSES_OF_HOLDINGREGISTERS.MeasuringSupplyVoltagePeriod,
// 1, out registers);
//if (result.Error == Modbus.OSIModel.ApplicationLayer.Error.NoError)
//{
// period = registers[0];
// error = new OperationResult(true, String.Empty);
//}
//else
//{
// error = new OperationResult(false, result.Description);
//}
//return;
}
