/// <summary>
/// Расчет для стандартного IO-Link модуля от Phoenix Contact.
/// </summary>
private void CalculateForPhoenixContact()
{
foreach (int clamp in moduleInfo.ChannelClamps)
{
if (devices[clamp] != null && devices[clamp][0] != null)
{
int deviceOffset;
Device.IODevice.IOChannel channel =
devicesChannels[clamp][0];
Device.IODevice device = devices[clamp][0];
if (channel.Name == "DI" || channel.Name == "DO")
{
int moduleOffset = channel.ModuleOffset;
int logicalClamp = channel.LogicalClamp;
int discreteOffset = CalculateDiscreteOffsetForIOLink(
moduleOffset, logicalClamp);
moduleInfo.ChannelAddressesIn[clamp] = discreteOffset;
moduleInfo.ChannelAddressesOut[clamp] = discreteOffset;
}
else
{
moduleInfo.ChannelAddressesIn[clamp] = offsetIn;
moduleInfo.ChannelAddressesOut[clamp] = offsetOut;
deviceOffset = device.IOLinkProperties.GetMaxIOLinkSize();
offsetIn += deviceOffset;
offsetOut += deviceOffset;
}
}
}
}
/// <summary>
/// Проверка действий в шаге
/// </summary>
/// <returns>Строка с ошибками</returns>
public string Check()
{
var errors = string.Empty;
List <int> devicesInAction = new List <int>();
foreach (Action a in actions)
{
if (a.GetType().Name == "Action" &&
(a.DisplayText[0].Contains("Включать") ||
a.DisplayText[0].Contains("Выключать")))
{
devicesInAction.AddRange(a.DeviceIndex);
}
}
List <int> FindEqual = devicesInAction.GroupBy(x => x)
.SelectMany(y => y.Skip(1)).Distinct().ToList();
foreach (int i in FindEqual)
{
State state = Owner;
Mode mode = state.Owner;
ModesManager modesManager = mode.Owner;
TechObject techObject = modesManager.Owner;
Device.IODevice device = Device.DeviceManager.GetInstance()
.GetDeviceByIndex(i);
string msg = $"Неправильно заданы устройства в шаге " +
$"\"{GetStepName()}\", операции \"{mode.Name}\"," +
$"технологического объекта " +
$"\"{techObject.DisplayText[0]}\"\n";
errors += msg;
}
return(errors);
}
/// <summary>
/// Подготовка слепка устройств, которые есть сейчас.
/// </summary>
private void PreparePreviouslyDevices()
{
int devicesCount = deviceReader.DevicesCount;
prevDevices = new Device.IODevice[devicesCount];
deviceReader.CopyDevices(prevDevices);
}
public void GetDeviceSubTypeStrTest(string expectedType,
string subType, Device.IODevice device)
{
device.SetSubType(subType);
Assert.AreEqual(expectedType, device.GetDeviceSubTypeStr(
device.DeviceType, device.DeviceSubType));
}
/// <summary>
/// Функция, проверяющая необходимость удаления комментариев в
/// функциональном тексте.
/// </summary>
/// <param name="devices">Строка со списком устройств</param>
/// <returns></returns>
private bool NeedDeletingComments(string devices)
{
var deviceMatches = Regex.Matches(devices,
Device.DeviceManager.DeviceNamePattern);
if (deviceMatches.Count > MinimalDevicesCountForCheck)
{
// Если первое устройство с подтипом AS-интерфейс,
// то все такие
for (int i = 0; i < MinimalDevicesCountForCheck; i++)
{
Device.IODevice device = Device.DeviceManager.
GetInstance().GetDevice(deviceMatches[i].Value);
if (device.DeviceSubType == Device.DeviceSubType.
V_AS_DO1_DI2 ||
device.DeviceSubType == Device.DeviceSubType.
V_AS_MIXPROOF)
{
return(false);
}
}
return(true);
}
else
{
return(false);
}
}
public void GetDevicePropertiesTest(List <string> expectedProperties,
string subType, Device.IODevice device)
{
device.SetSubType(subType);
Assert.AreEqual(expectedProperties, device.GetDeviceProperties(
device.DeviceType, device.DeviceSubType));
}
/// <summary>
/// Сделать узел устройства
/// </summary>
/// <param name="devTypeNode">Узел типа устройства</param>
/// <param name="dev">Устройство</param>
/// <param name="deviceDescription">Описание устройства</param>
/// <param name="devObjectNode">Узел объекта или null</param>
/// <returns>Заполненный узел</returns>
private Node MakeDeviceNode(Node devTypeNode, Node devObjectNode,
Device.IODevice dev, string deviceDescription)
{
Node devNode;
if (dev.ObjectName != "")
{
string devName = dev.DeviceType + dev.DeviceNumber.ToString() +
"\t " + deviceDescription;
devNode = new Node(devName);
}
else
{
devNode = new Node(dev.name + "\t " + deviceDescription);
}
devNode.Tag = dev;
if (devObjectNode != null)
{
devObjectNode.Nodes.Add(devNode);
}
else
{
devTypeNode.Nodes.Add(devNode);
}
return(devNode);
}
public void GetRangeTest(string expected, string subType,
double value1, double value2, Device.IODevice device)
{
device.SetSubType(subType);
device.SetParameter("P_MIN_V", value1);
device.SetParameter("P_MAX_V", value2);
Assert.AreEqual(expected, device.GetRange());
}
public void ParametersTest(string[] parametersSequence, string subType,
Device.IODevice device)
{
device.SetSubType(subType);
string[] actualParametersSequence = device.Parameters
.Select(x => x.Key)
.ToArray();
Assert.AreEqual(parametersSequence, actualParametersSequence);
}
virtual public void ModifyDevNames(int newTechObjectN,
int oldTechObjectN, string techObjectName)
{
List <int> tmpIndex = new List <int>();
foreach (int index in deviceIndex)
{
tmpIndex.Add(index);
}
Device.DeviceManager deviceManager = Device.DeviceManager
.GetInstance();
foreach (int index in deviceIndex)
{
var newDevName = string.Empty;
Device.IODevice device = deviceManager.GetDeviceByIndex(index);
int objNum = device.ObjectNumber;
string objName = device.ObjectName;
if (objNum > 0)
{
//Для устройств в пределах объекта меняем номер объекта.
if (techObjectName == objName)
{
// COAG2V1 --> COAG1V1
if (objNum == newTechObjectN && oldTechObjectN != -1)
{
newDevName = objName + oldTechObjectN +
device.DeviceType.ToString() + device.
DeviceNumber;
}
if (oldTechObjectN == -1 ||
oldTechObjectN == objNum)
{
//COAG1V1 --> COAG2V1
newDevName = objName + newTechObjectN +
device.DeviceType.ToString() + device
.DeviceNumber;
}
}
}
if (newDevName != string.Empty)
{
int indexOfDeletingElement = tmpIndex.IndexOf(index);
tmpIndex.Remove(index);
int tmpDevInd = Device.DeviceManager.GetInstance()
.GetDeviceIndex(newDevName);
if (tmpDevInd >= 0)
{
tmpIndex.Insert(indexOfDeletingElement, tmpDevInd);
}
}
}
deviceIndex = tmpIndex;
}
public void TestSortingChannelsForVDevice(Device.IODevice dev,
string subType, string[] expected)
{
dev.SetSubType(subType);
dev.sortChannels();
string[] actual = dev.Channels
.Where(x => x.Comment != "")
.Select(x => x.Comment).ToArray();
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Синхронизация.
/// 1.Создаем массив целочисленных флагов, количество элементов в
///котором равняется количеству элементов в массиве ранее считанных
///устройств. Все элементы массива флагов устанавливаются в 0. Далее
///будем считать, что если флаг = 0, то индекс объекта не изменился,
///если флаг = -1, то индекс объекта помечен на удаление, если
///флаг > 0, то изменяем старый индекс в операции на значение флага.
///2. Для каждого элемента массива предыдущих устройств проверяем
///соответствие элементу нового списка.
///2.1. Если объект, находящийся в старом списке был уже удален, то
///обрабатываем исключение. Устанавливаем флаг элемента старого списка
///в -1.
///2.2. Пробуем проверить равенство объектов в двух списках устройств.
///Если элемент нового списка входит в старый, то проверяем равенство
///их имен.
///3. Вызываем функцию синхронизации индексов, которая убирает
///удаленные устройства.
/// </summary>
private void SynchronizeDevices()
{
int prevDevicesCount = prevDevices.Length;
int[] indexArray = new int[prevDevicesCount]; //1
bool needSynch = false;
for (int k = 0; k < prevDevicesCount; k++) //2
{
Device.IODevice prevDevice = prevDevices[k];
var prevDevEplanObjFunc = prevDevice.EplanObjectFunction;
if (prevDevEplanObjFunc == null ||
(k < deviceReader.DevicesCount &&
prevDevice.Name == deviceReader.Devices[k].Name))
{
// Т.к если мы не заполним, то будет "0", а это съест другой
// алгоритм приняв за устройство.
indexArray[k] = -2;
continue;
}
needSynch = true;
int idx = -1;
foreach (Device.IODevice newDev in deviceReader.Devices)
{
idx++;
const string deviceSkipSign = "1"; //2.1
if (prevDevEplanObjFunc.IsValid != true ||
(prevDevEplanObjFunc.Properties
.FUNC_SUPPLEMENTARYFIELD[1].IsEmpty != true &&
prevDevEplanObjFunc.Properties
.FUNC_SUPPLEMENTARYFIELD[1]
.ToString(ISOCode.Language.L___) == deviceSkipSign))
{
indexArray[k] = -1;
break;
}
if (newDev.EplanObjectFunction == prevDevEplanObjFunc) //2.2
{
indexArray[k] = idx;
break;
}
}
}
if (needSynch) //3
{
techObjectManager.Synch(indexArray);
}
}
/// <summary>
/// Синхронизация.
/// 1.Создаем массив целочисленных флагов, количество элементов в
///котором равняется количеству элементов в массиве ранее считанных
///устройств. Все элементы массива флагов устанавливаются в 0. Далее
///будем считать, что если флаг = 0, то индекс объекта не изменился,
///если флаг = -1, то индекс объекта помечен на удаление, если
///флаг > 0, то изменяем старый индекс в операции на значение флага.
///2. Для каждого элемента массива предыдущих устройств проверяем
///соответствие элементу нового списка.
///2.1. Пробуем проверить равенство объектов в двух списках устройств.
///Если элемент нового списка входит в старый, то проверяем равенство
///их имен.
///2.2.Если имена неравны, проверяем равенство их индексов в списках.
///Индексы не совпадают - в массиве флагов изменяем соответствующий
///элемент на новый индекс.
///2.3. Проверяем индексы одинаковых объектов, если они неравны, то
///аналогично изменяем флаг на новый индекс.
///2.4. Если объект, находящийся в старом списке был уже удален, то
///обрабатываем исключение. Устанавливаем флаг элемента старого списка
///в -1.
///3. Вызываем функцию синхронизации индексов, которая убирает
///удаленные устройства.
/// </summary>
private void SynchronizeDevices()
{
int prevDevicesCount = previouslyDevices.Length;
int[] indexArray = new int[prevDevicesCount]; //1
for (int i = 0; i < prevDevicesCount; i++)
{
indexArray[i] = 0;
}
bool needSynch = false;
for (int k = 0; k < prevDevicesCount; k++) //2
{
Device.IODevice prevDevice = previouslyDevices[k];
try
{
if (prevDevice.EplanObjectFunction == null)
{
continue;
}
if (k < deviceReader.DevicesCount &&
prevDevice.Name == deviceReader.Devices[k].Name)
{
continue;
}
needSynch = true;
int idx = -1;
foreach (Device.IODevice newDev in deviceReader.Devices)
{
idx++;
if (newDev.EplanObjectFunction == prevDevice //2.1
.EplanObjectFunction)
{
indexArray[k] = idx;
break;
}
}
}
catch //2.4
{
indexArray[k] = -1;
}
}
if (needSynch) //3
{
techObjectManager.Synch(indexArray);
}
}
/// <summary>
/// Поиск узла типа устройства
/// </summary>
/// <param name="root">главный узел</param>
/// <param name="dev">Устройство</param>
/// <returns></returns>
private Node FindDevTypeNode(Node root, Device.IODevice dev)
{
foreach (Node node in root.Nodes)
{
if (node.Tag is Device.DeviceType &&
(Device.DeviceType)node.Tag == dev.DeviceType)
{
return(node);
}
}
return(null);
}
/// <summary>
/// Изменение состояния CheckBox
/// </summary>
/// <param name="dev">Устройство</param>
/// <param name="checkedDev">Выбранные устройств в действии</param>
/// <param name="devNode">Узел устройства</param>
private void ChangeDevicesCheckState(Node devNode, string checkedDev,
Device.IODevice dev)
{
checkedDev = ' ' + checkedDev + ' ';
if (checkedDev != " " &&
checkedDev.Contains(' ' + dev.Name + ' '))
{
devNode.CheckState = CheckState.Checked;
}
else
{
devNode.CheckState = CheckState.Unchecked;
}
}
/// <summary>
/// Поиск узла подтипа устройства
/// </summary>
/// <param name="dev">Устройство</param>
/// <param name="root">Главный узел</param>
/// <returns></returns>
private Node FindDevSubTypeNode(Node root, Device.IODevice dev)
{
foreach (Node node in root.Nodes)
{
string devSubType = dev.GetDeviceSubTypeStr(dev.DeviceType,
dev.DeviceSubType);
if (node.Tag is Device.DeviceSubType &&
node.Text == devSubType)
{
return(node);
}
}
return(null);
}
/// <summary>
/// Компаратор для сравнения устройств с
/// AS-интерфейсом (сортировки).
/// </summary>
/// <param name="device1">Устройство 1</param>
/// <param name="device2">Устройство 2</param>
/// <returns></returns>
private int ASInterfaceDevicesComparer(Device.IODevice device1,
Device.IODevice device2)
{
string device1ASNumberString = device1.
GetRuntimeParameter("R_AS_NUMBER");
string device2ASNumberString = device2.
GetRuntimeParameter("R_AS_NUMBER");
int device1ASNumber;
int device2ASNumber;
int.TryParse(device1ASNumberString, out device1ASNumber);
int.TryParse(device2ASNumberString, out device2ASNumber);
return(device1ASNumber.CompareTo(device2ASNumber));
}
public void ChannelsTest(Dictionary <string, int> expectedChannelsCount,
string subType, Device.IODevice device)
{
device.SetSubType(subType);
int actualAI = device.Channels.Where(x => x.Name == "AI").Count();
int actualAO = device.Channels.Where(x => x.Name == "AO").Count();
int actualDI = device.Channels.Where(x => x.Name == "DI").Count();
int actualDO = device.Channels.Where(x => x.Name == "DO").Count();
Assert.Multiple(() =>
{
Assert.AreEqual(expectedChannelsCount["AI"], actualAI);
Assert.AreEqual(expectedChannelsCount["AO"], actualAO);
Assert.AreEqual(expectedChannelsCount["DI"], actualDI);
Assert.AreEqual(expectedChannelsCount["DO"], actualDO);
});
}
/// <summary>
/// Заполнить узел для подтипа устройства
/// </summary>
/// <param name="dev">Устройство</param>
/// <param name="root">Главный узел</param>
/// <param name="deviceDescription">Описание устройства</param>
/// <param name="countDev">Словарь для подсчета количества</param>
private void FillSubTypeNode(Device.IODevice dev, Node root,
string deviceDescription, Dictionary <string, int> countDev)
{
Node devSubTypeNode = FindDevSubTypeNode(root, dev);
if (devSubTypeNode == null)
{
return;
}
Node subDevObjectNode = MakeObjectNode(dev.ObjectName,
dev.ObjectNumber, devSubTypeNode);
Node subDevNode = MakeDeviceNode(devSubTypeNode,
subDevObjectNode, dev, deviceDescription);
bool isDevVisible = noAssigmentBtn.Checked ? false : true;
HideIncorrectDeviceTypeSubType(subDevNode, isDevVisible, countDev,
dev);
}
/// <summary>
/// Генерация описания устройства
/// </summary>
/// <param name="dev">Устройство</param>
/// <returns></returns>
private string GenerateDeviceDescription(Device.IODevice dev)
{
string result = "";
if (dev.Description.Contains('\n'))
{
string[] devDescr = dev.Description.Split('\n');
foreach (string str in devDescr)
{
result += str + " ";
}
}
else
{
result = dev.Description;
}
return(result);
}
virtual public void ModifyDevNames(string newTechObjectName,
int newTechObjectNumber, string oldTechObjectName,
int oldTechObjNumber)
{
List <int> tmpIndex = new List <int>();
foreach (int index in deviceIndex)
{
tmpIndex.Add(index);
}
Device.DeviceManager deviceManager = Device.DeviceManager
.GetInstance();
foreach (int index in deviceIndex)
{
string newDevName = string.Empty;
Device.IODevice device = deviceManager.GetDeviceByIndex(index);
int objNum = newTechObjectNumber;
string objName = device.ObjectName;
if (objName == oldTechObjectName &&
device.ObjectNumber == oldTechObjNumber)
{
newDevName = newTechObjectName + objNum +
device.DeviceType.ToString() + device.DeviceNumber;
}
if (newDevName != string.Empty)
{
int indexOfDeletingElement = tmpIndex.IndexOf(index);
tmpIndex.Remove(index);
int tmpDevInd = Device.DeviceManager.GetInstance()
.GetDeviceIndex(newDevName);
if (tmpDevInd >= 0)
{
tmpIndex.Insert(indexOfDeletingElement, tmpDevInd);
}
}
}
deviceIndex = tmpIndex;
}
public void AssignChannelToDevice(int chN, Device.IODevice dev,
Device.IODevice.IOChannel ch)
{
if (devices.GetLength(0) <= chN)
{
System.Windows.Forms.MessageBox.Show("Error!");
}
if (devices[chN] == null)
{
devices[chN] = new List <Device.IODevice>();
}
if (devicesChannels[chN] == null)
{
devicesChannels[chN] = new List <Device.IODevice.IOChannel>();
}
devices[chN].Add(dev);
devicesChannels[chN].Add(ch);
}
/// <summary>
/// Получение устройств, привязанных к пневмоострову.
/// </summary>
/// <param name="functionalText">Функциональный текст
/// пневмоострова, к которому привязано устройство</param>
/// <returns></returns>
private Dictionary <int, string> GetValveTerminalDevices
(string functionalText)
{
const string ClampNumberParameter = "R_VTUG_NUMBER";
string[] devicesArray = functionalText.Split(PlusSymbol);
var valveTerminalDevices = new Dictionary <int, string>();
foreach (string deviceString in devicesArray)
{
if (string.IsNullOrEmpty(deviceString) ||
string.IsNullOrWhiteSpace(deviceString) ||
deviceString
.Contains(Device.DeviceManager.ValveTerminalName))
{
continue;
}
string deviceName = Regex.Match(deviceString.
Insert(0, PlusSymbol.ToString()),
Device.DeviceManager.DeviceNamePattern).Value;
Device.IODevice device = Device.DeviceManager.
GetInstance().GetDevice(deviceName);
string clampNumber = device.GetRuntimeParameter(
ClampNumberParameter);
var clamp = Convert.ToInt32(clampNumber);
if (valveTerminalDevices.ContainsKey(clamp))
{
valveTerminalDevices[clamp] += deviceString.
Insert(0, PlusSymbol.ToString());
}
else
{
valveTerminalDevices.Add(clamp, deviceString.
Insert(0, PlusSymbol.ToString()));
}
}
return(valveTerminalDevices);
}
/// <summary>
/// Заполнить узел для типа устройства
/// </summary>
/// <param name="dev">Устройство</param>
/// <param name="root">Главный узел</param>
/// <param name="deviceDescription">Описание устройства</param>
/// <param name="countDev">Словарь для подсчета количества</param>
/// <param name="checkedDev">Выбранные устройств в действии</param>
private void FillTypeNode(Device.IODevice dev, Node root,
string deviceDescription, Dictionary <string, int> countDev,
string checkedDev)
{
Node devTypeNode = FindDevTypeNode(root, dev);
if (devTypeNode == null)
{
return;
}
Node devObjectNode = MakeObjectNode(dev.ObjectName,
dev.ObjectNumber, devTypeNode);
Node devNode = MakeDeviceNode(devTypeNode, devObjectNode,
dev, deviceDescription);
ChangeDevicesCheckState(devNode, checkedDev, dev);
bool isDevVisible = AddDevChannels(devNode, dev);
HideIncorrectDeviceTypeSubType(devNode, isDevVisible, countDev,
dev);
}
/// <summary>
/// Отображение каналов устройств
/// </summary>
/// <param name="devNode">Узел устройства</param>
/// <param name="dev">Устройство</param>
/// <returns></returns>
private bool AddDevChannels(Node devNode, Device.IODevice dev)
{
bool isDevVisible = false;
if (prevShowChannels)
{
Node channelNode;
//Показываем каналы.
foreach (Device.IODevice.IOChannel ch in dev.Channels)
{
if (!ch.IsEmpty())
{
channelNode = new Node(ch.Name + " " + ch.Comment +
$" (A{ch.FullModule}:" + ch.PhysicalClamp + ")");
channelNode.Tag = ch;
devNode.Nodes.Add(channelNode);
if (noAssigmentBtn.Checked)
{
channelNode.IsHidden = true;
}
else
{
isDevVisible = true;
}
}
else
{
channelNode = new Node(ch.Name + " " + ch.Comment);
channelNode.Tag = ch;
devNode.Nodes.Add(channelNode);
isDevVisible = true;
}
}
}
return(isDevVisible);
}
/// <summary>
/// Скрываем устройства ненужных подтипов и типов
/// </summary>
/// <param name="dev">Устройство</param>
/// <param name="countDev">Словарь для подсчета количества устройств
/// </param>
/// <param name="devTypeSubTypeNode">Узел типа или подтипа</param>
/// <param name="isDevVisible">Видимость устройства</param>
private void HideIncorrectDeviceTypeSubType(Node devTypeSubTypeNode,
bool isDevVisible, Dictionary <string, int> countDev,
Device.IODevice dev)
{
if (devTypesLastSelected != null &&
!devTypesLastSelected.Contains(dev.DeviceType))
{
devTypeSubTypeNode.IsHidden = true;
}
else
{
if (devSubTypesLastSelected != null &&
!devSubTypesLastSelected.Contains(dev.DeviceSubType))
{
devTypeSubTypeNode.IsHidden = true;
}
else
{
if (prevShowChannels && !isDevVisible)
{
devTypeSubTypeNode.IsHidden = true;
}
else
{
string subTypeName = dev.GetDeviceSubTypeStr(
dev.DeviceType, dev.DeviceSubType);
if (subTypeName != "" &&
countDev.ContainsKey(subTypeName))
{
countDev[subTypeName]++;
}
else
{
countDev[dev.DeviceType.ToString()]++;
}
}
}
}
}
public void CompareToTest(int expected, Device.IODevice dev,
object otherDevice)
{
Assert.AreEqual(expected, dev.CompareTo(otherDevice));
}
public void GetConnectionTest(string expected, string subType,
Device.IODevice device)
{
device.SetSubType(subType);
Assert.AreEqual(expected, device.GetConnectionType());
}
public void CompareTest(int expected, Device.IODevice x,
Device.IODevice y)
{
Assert.AreEqual(expected, Device.Device.Compare(x, y));
}
public void SetSubTypeTest(Device.DeviceSubType expectedSubType,
string subType, Device.IODevice device)
{
device.SetSubType(subType);
Assert.AreEqual(expectedSubType, device.DeviceSubType);
}
