1479 lines
43 KiB
C
1479 lines
43 KiB
C
/**
|
|
* @file GoEthernet.c
|
|
*
|
|
* @internal
|
|
* Copyright (C) 2016-2021 by LMI Technologies Inc.
|
|
* Licensed under the MIT License.
|
|
* Redistributed files must retain the above copyright notice.
|
|
*/
|
|
#include <GoSdk/Outputs/GoEthernet.h>
|
|
#include <GoSdk/GoUtils.h>
|
|
#include <GoSdk/GoSensor.h>
|
|
#include <stdio.h>
|
|
|
|
kBeginClassEx(Go, GoEthernet)
|
|
kAddVMethod(GoEthernet, kObject, VRelease)
|
|
kEndClassEx()
|
|
|
|
// Table of the Ethernet Output sources and their configuration XML tag names.
|
|
GoValueNamePair g_EthernetOutputSourceTypeMap[] =
|
|
{
|
|
{ GO_OUTPUT_SOURCE_VIDEO, "Videos" },
|
|
{ GO_OUTPUT_SOURCE_RANGE, "Ranges" },
|
|
{ GO_OUTPUT_SOURCE_PROFILE, "Profiles" },
|
|
{ GO_OUTPUT_SOURCE_SURFACE, "Surfaces" },
|
|
{ GO_OUTPUT_SOURCE_SECTION, "SurfaceSections" },
|
|
{ GO_OUTPUT_SOURCE_RANGE_INTENSITY, "RangeIntensities" },
|
|
{ GO_OUTPUT_SOURCE_PROFILE_INTENSITY, "ProfileIntensities" },
|
|
{ GO_OUTPUT_SOURCE_SURFACE_INTENSITY, "SurfaceIntensities" },
|
|
{ GO_OUTPUT_SOURCE_SECTION_INTENSITY, "SurfaceSectionsIntensities" },
|
|
{ GO_OUTPUT_SOURCE_MEASUREMENT, "Measurements" },
|
|
{ GO_OUTPUT_SOURCE_TRACHEID, "Tracheids" },
|
|
{ GO_OUTPUT_SOURCE_EVENT, "Events" },
|
|
{ GO_OUTPUT_SOURCE_FEATURE, "Features" },
|
|
{ GO_OUTPUT_SOURCE_TOOLDATA, "ToolDataOutputs" }
|
|
};
|
|
|
|
GoFx(kStatus) GoEthernet_Construct(GoEthernet* ethernet, kObject sensor, kAlloc allocator)
|
|
{
|
|
kAlloc alloc = kAlloc_Fallback(allocator);
|
|
kStatus status;
|
|
|
|
kCheck(kAlloc_GetObject(alloc, kTypeOf(GoEthernet), ethernet));
|
|
|
|
if (!kSuccess(status = GoEthernet_Init(*ethernet, kTypeOf(GoEthernet), sensor, alloc)))
|
|
{
|
|
kAlloc_FreeRef(alloc, ethernet);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_Init(GoEthernet ethernet, kType type, kObject sensor, kAlloc alloc)
|
|
{
|
|
kObjR(GoEthernet, ethernet);
|
|
kStatus exception;
|
|
|
|
kCheck(kObject_Init(ethernet, type, alloc));
|
|
kZero(obj->xml);
|
|
kZero(obj->xmlItem);
|
|
kZero(obj->videoOptions);
|
|
kZero(obj->videoSources);
|
|
kZero(obj->rangeOptions);
|
|
kZero(obj->rangeSources);
|
|
kZero(obj->rangeIntensityOptions);
|
|
kZero(obj->rangeIntensitySources);
|
|
kZero(obj->profileOptions);
|
|
kZero(obj->profileSources);
|
|
kZero(obj->profileIntensityOptions);
|
|
kZero(obj->profileIntensitySources);
|
|
kZero(obj->surfaceIntensityOptions);
|
|
kZero(obj->surfaceIntensitySources);
|
|
kZero(obj->surfaceOptions);
|
|
kZero(obj->surfaceSources);
|
|
kZero(obj->sectionIntensityOptions);
|
|
kZero(obj->sectionIntensitySources);
|
|
kZero(obj->sectionOptions);
|
|
kZero(obj->sectionSources);
|
|
kZero(obj->measurementOptions);
|
|
kZero(obj->measurementSources);
|
|
kZero(obj->eventOptions);
|
|
kZero(obj->events);
|
|
kZero(obj->tracheidOptions);
|
|
kZero(obj->tracheidSources);
|
|
kZero(obj->featureOptions);
|
|
kZero(obj->featureSources);
|
|
kZero(obj->toolDataOptions);
|
|
kZero(obj->toolDataSources);
|
|
obj->outputUsed = kFALSE;
|
|
obj->protocol = GO_ETHERNET_PROTOCOL_GOCATOR;
|
|
kZero(obj->eip);
|
|
kZero(obj->modbus);
|
|
kZero(obj->ascii);
|
|
kZero(obj->profinet);
|
|
kZero(obj->ptp);
|
|
|
|
obj->sensor = sensor;
|
|
|
|
// Auto-disconnect is available and enabled by default.
|
|
obj->timeoutEnabled = kTRUE;
|
|
obj->timeoutEnabledAvail = kTRUE;
|
|
|
|
obj->timeout = 10.0;
|
|
|
|
kTry
|
|
{
|
|
kTest(kArrayList_Construct(&obj->videoOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->videoSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->rangeOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->rangeSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->rangeIntensityOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->rangeIntensitySources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->profileOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->profileSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->profileIntensityOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->profileIntensitySources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->surfaceOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->surfaceSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->surfaceIntensityOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->surfaceIntensitySources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->sectionOptions, kTypeOf(GoOutputCompositeSource), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->sectionSources, kTypeOf(GoOutputCompositeSource), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->sectionIntensityOptions, kTypeOf(GoOutputCompositeSource), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->sectionIntensitySources, kTypeOf(GoOutputCompositeSource), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->measurementOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->measurementSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->eventOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->events, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->tracheidOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->tracheidSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->featureOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->featureSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kArrayList_Construct(&obj->toolDataOptions, kTypeOf(k32s), 0, alloc));
|
|
kTest(kArrayList_Construct(&obj->toolDataSources, kTypeOf(k32s), 0, alloc));
|
|
|
|
kTest(kString_Construct(&obj->ascii.customFormat, "", alloc));
|
|
kTest(kString_Construct(&obj->ascii.delimiter, "", alloc));
|
|
kTest(kString_Construct(&obj->ascii.invalidValue, "", alloc));
|
|
kTest(kString_Construct(&obj->ascii.terminator, "", alloc));
|
|
|
|
kTest(kString_Construct(&obj->profinet.deviceName, "", alloc));
|
|
}
|
|
kCatch(&exception)
|
|
{
|
|
GoEthernet_VRelease(ethernet);
|
|
kEndCatch(exception);
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_VRelease(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheck(kDisposeRef(&obj->videoOptions));
|
|
kCheck(kDisposeRef(&obj->videoSources));
|
|
|
|
kCheck(kDisposeRef(&obj->rangeOptions));
|
|
kCheck(kDisposeRef(&obj->rangeSources));
|
|
|
|
kCheck(kDisposeRef(&obj->rangeIntensityOptions));
|
|
kCheck(kDisposeRef(&obj->rangeIntensitySources));
|
|
|
|
kCheck(kDisposeRef(&obj->profileOptions));
|
|
kCheck(kDisposeRef(&obj->profileSources));
|
|
|
|
kCheck(kDisposeRef(&obj->profileIntensityOptions));
|
|
kCheck(kDisposeRef(&obj->profileIntensitySources));
|
|
|
|
kCheck(kDisposeRef(&obj->surfaceOptions));
|
|
kCheck(kDisposeRef(&obj->surfaceSources));
|
|
|
|
kCheck(kDisposeRef(&obj->surfaceIntensityOptions));
|
|
kCheck(kDisposeRef(&obj->surfaceIntensitySources));
|
|
|
|
kCheck(kDisposeRef(&obj->sectionOptions));
|
|
kCheck(kDisposeRef(&obj->sectionSources));
|
|
|
|
kCheck(kDisposeRef(&obj->sectionIntensityOptions));
|
|
kCheck(kDisposeRef(&obj->sectionIntensitySources));
|
|
|
|
kCheck(kDisposeRef(&obj->measurementOptions));
|
|
kCheck(kDisposeRef(&obj->measurementSources));
|
|
|
|
kCheck(kDisposeRef(&obj->eventOptions));
|
|
kCheck(kDisposeRef(&obj->events));
|
|
|
|
kCheck(kDisposeRef(&obj->tracheidOptions));
|
|
kCheck(kDisposeRef(&obj->tracheidSources));
|
|
|
|
kCheck(kDisposeRef(&obj->featureOptions));
|
|
kCheck(kDisposeRef(&obj->featureSources));
|
|
|
|
kCheck(kDisposeRef(&obj->toolDataOptions));
|
|
kCheck(kDisposeRef(&obj->toolDataSources));
|
|
|
|
kCheck(kDestroyRef(&obj->ascii.customFormat));
|
|
kCheck(kDestroyRef(&obj->ascii.delimiter));
|
|
kCheck(kDestroyRef(&obj->ascii.invalidValue));
|
|
kCheck(kDestroyRef(&obj->ascii.terminator));
|
|
|
|
kCheck(kDestroyRef(&obj->profinet.deviceName));
|
|
|
|
return kObject_VRelease(ethernet);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ParseOutputList(GoOutputSource outputSource, kChar* text, kArrayList outputList)
|
|
{
|
|
if (outputSource == GO_OUTPUT_SOURCE_EVENT)
|
|
{
|
|
// Events are of type GoEventType which is a signed integer.
|
|
kCheck(GoOptionList_ParseList32s(text, outputList));
|
|
}
|
|
else if ((outputSource == GO_OUTPUT_SOURCE_SECTION) ||
|
|
(outputSource == GO_OUTPUT_SOURCE_SECTION_INTENSITY))
|
|
{
|
|
// Not typical ints -> actually of the form "ID-DataSource".
|
|
kCheck(GoEthernet_ParseCompositeOptionList(text, outputList));
|
|
}
|
|
else
|
|
{
|
|
kCheck(GoOptionList_ParseList32u(text, outputList));
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ParseOutputOptionList(GoEthernet ethernet, GoOutputSource outputSource, kChar* text)
|
|
{
|
|
kArrayList outputList;
|
|
|
|
outputList = GoEthernet_OptionList(ethernet, outputSource);
|
|
kCheckState(!kIsNull(outputList));
|
|
|
|
kCheck(GoEthernet_ParseOutputList(outputSource, text, outputList));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ParseOutputSourceList(GoEthernet ethernet, GoOutputSource outputSource, kChar* text)
|
|
{
|
|
kArrayList outputList;
|
|
|
|
outputList = GoEthernet_SourceList(ethernet, outputSource);
|
|
kCheckState(!kIsNull(outputList));
|
|
|
|
kCheck(GoEthernet_ParseOutputList(outputSource, text, outputList));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ReadAllOutputConfig(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kChar* text = kNULL;
|
|
kSize textCapacity = GO_OUTPUT_SOURCE_TEXT_CAPACITY;
|
|
kXmlItem tempItem = kNULL;
|
|
kSize i;
|
|
kSize numMapEntry = kCountOf(g_EthernetOutputSourceTypeMap);
|
|
GoValueNamePair* tableEntry;
|
|
|
|
kTry
|
|
{
|
|
kTest(kObject_GetMemZero(ethernet, sizeof(kChar) * textCapacity, &text));
|
|
|
|
for (i = 0; i < numMapEntry; i++)
|
|
{
|
|
tableEntry = &g_EthernetOutputSourceTypeMap[i];
|
|
|
|
tempItem = kXml_Child(obj->xml, obj->xmlItem, tableEntry->name);
|
|
if (!kIsNull(tempItem))
|
|
{
|
|
kTest(kXml_AttrText(obj->xml, tempItem, "options", text, textCapacity));
|
|
kTest(GoEthernet_ParseOutputOptionList(ethernet, (GoOutputSource) tableEntry->value, text));
|
|
|
|
kTest(kXml_ItemText(obj->xml, tempItem, text, textCapacity));
|
|
kTest(GoEthernet_ParseOutputSourceList(ethernet, (GoOutputSource) tableEntry->value, text));
|
|
}
|
|
}
|
|
}
|
|
kFinally
|
|
{
|
|
kObject_FreeMem(ethernet, text);
|
|
kEndFinally();
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_Read(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
obj->xml = xml;
|
|
obj->xmlItem = item;
|
|
|
|
kTry
|
|
{
|
|
tempItem = kXml_Child(xml, item, "TimeoutEnabled");
|
|
if (!kIsNull(tempItem))
|
|
{
|
|
kTest(kXml_ItemBool(xml, tempItem, &obj->timeoutEnabled));
|
|
// Set default value to true to match legacy behaviour, if
|
|
// the configuration file does not have this attribute.
|
|
kTest(GoConfig_ReadAttrBoolOptional(xml, tempItem, "used", kTRUE, &obj->timeoutEnabledAvail));
|
|
|
|
kTest(kXml_Child64f(xml, item, "Timeout", &obj->timeout));
|
|
}
|
|
|
|
kTest(GoConfig_ReadAttrBoolOptional(xml, item, "used", kTRUE, &obj->outputUsed));;
|
|
kTest(kXml_Child32s(xml, item, "Protocol", (k32s*)&obj->protocol));
|
|
|
|
kTest(GoEthernet_ReadAscii(ethernet, xml, item));
|
|
kTest(GoEthernet_ReadEip(ethernet, xml, item));
|
|
kTest(GoEthernet_ReadModbus(ethernet, xml, item));
|
|
kTest(GoEthernet_ReadProfinet(ethernet, xml, item));
|
|
kTest(GoEthernet_ReadPtp(ethernet, xml, item));
|
|
kTest(GoEthernet_ReadAllOutputConfig(ethernet));
|
|
}
|
|
kFinally
|
|
{
|
|
kEndFinally();
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_WriteAllOutputConfig(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kChar* text = kNULL;
|
|
kSize textCapacity = GO_OUTPUT_SOURCE_TEXT_CAPACITY;
|
|
GoValueNamePair* tableEntry;
|
|
kSize i;
|
|
kSize numMapEntry = kCountOf(g_EthernetOutputSourceTypeMap);
|
|
kArrayList sourceList;
|
|
|
|
kTry
|
|
{
|
|
kTest(kObject_GetMemZero(ethernet, sizeof(kChar) * textCapacity, &text));
|
|
|
|
for (i = 0; i < numMapEntry; i++)
|
|
{
|
|
tableEntry = &g_EthernetOutputSourceTypeMap[i];
|
|
sourceList = GoEthernet_SourceList(ethernet, (GoOutputSource) tableEntry->value);
|
|
kTestState(!kIsNull(sourceList));
|
|
|
|
if (((GoOutputSource) tableEntry->value == GO_OUTPUT_SOURCE_SECTION) ||
|
|
((GoOutputSource) tableEntry->value == GO_OUTPUT_SOURCE_SECTION_INTENSITY))
|
|
{
|
|
kTest(GoOptionList_FormatOutputCompositeSource(kArrayList_DataT(sourceList, const GoOutputCompositeSource), kArrayList_Count(sourceList), text, textCapacity));
|
|
}
|
|
else
|
|
{
|
|
kTest(GoOptionList_Format32u(kArrayList_DataT(sourceList, const k32u), kArrayList_Count(sourceList), text, textCapacity));
|
|
}
|
|
kTest(kXml_SetChildText(xml, item, tableEntry->name, text));
|
|
}
|
|
}
|
|
kFinally
|
|
{
|
|
kObject_FreeMem(ethernet, text);
|
|
kEndFinally();
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_Write(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
kTry
|
|
{
|
|
kTest(kXml_SetChild32s(xml, item, "Protocol", obj->protocol));
|
|
|
|
// Only need to send the TimeoutEnabled value to the sensor.
|
|
// The "used" attribute is only sent from sensor to client, never
|
|
// from client to sensor.
|
|
kTest(kXml_SetChildBool(xml, item, "TimeoutEnabled", obj->timeoutEnabled));
|
|
|
|
kTest(kXml_SetChild64f(xml, item, "Timeout", obj->timeout));
|
|
|
|
kTest(GoEthernet_WriteAscii(ethernet, xml, item));
|
|
kTest(GoEthernet_WriteEip(ethernet, xml, item));
|
|
kTest(GoEthernet_WriteModbus(ethernet, xml, item));
|
|
|
|
// Client never changes the Profinet parameters since it is
|
|
// read-only for the client. Therefore don't send the
|
|
// Profinet parameters back to the sensor.
|
|
|
|
kTest(GoEthernet_WriteAllOutputConfig(ethernet, xml, item));
|
|
}
|
|
kFinally
|
|
{
|
|
kEndFinally();
|
|
}
|
|
|
|
// Forwards Compatibility.
|
|
kCheck(GoUtils_XmlMerge(obj->xml, obj->xmlItem, xml, item));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ReadAscii(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
//ASCII config
|
|
tempItem = kXml_Child(xml, item, "Ascii");
|
|
if (!kIsNull(tempItem))
|
|
{
|
|
kCheck(kXml_Child32u(xml, tempItem, "Operation", (k32u*) &obj->ascii.operation));
|
|
kCheck(kXml_Child32u(xml, tempItem, "ControlPort", &obj->ascii.controlPort));
|
|
kCheck(kXml_Child32u(xml, tempItem, "DataPort", &obj->ascii.dataPort));
|
|
kCheck(kXml_Child32u(xml, tempItem, "HealthPort", &obj->ascii.healthPort));
|
|
kCheck(kXml_ChildString(xml, tempItem, "Delimiter", obj->ascii.delimiter));
|
|
kCheck(kXml_ChildString(xml, tempItem, "Terminator", obj->ascii.terminator));
|
|
kCheck(kXml_ChildString(xml, tempItem, "InvalidValue", obj->ascii.invalidValue));
|
|
kCheck(kXml_ChildString(xml, tempItem, "CustomDataFormat", obj->ascii.customFormat));
|
|
kCheck(kXml_ChildBool(xml, tempItem, "CustomFormatEnabled", &obj->ascii.customFormatEnabled));
|
|
|
|
if (kXml_ChildExists(xml, tempItem, "StandardFormatMode"))
|
|
{
|
|
kCheck(kXml_Child32s(xml, tempItem, "StandardFormatMode", &obj->ascii.standardFormatMode));
|
|
}
|
|
}
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_WriteAscii(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
//ASCII config
|
|
kCheck(kXml_AddItem(xml, item, "Ascii", &tempItem));
|
|
kCheck(kXml_SetChild32s(xml, tempItem, "Operation", obj->ascii.operation));
|
|
kCheck(kXml_SetChild32u(xml, tempItem, "ControlPort", obj->ascii.controlPort));
|
|
kCheck(kXml_SetChild32u(xml, tempItem, "DataPort", obj->ascii.dataPort));
|
|
kCheck(kXml_SetChild32u(xml, tempItem, "HealthPort", obj->ascii.healthPort));
|
|
kCheck(kXml_SetChildText(xml, tempItem, "Delimiter", kString_Chars(obj->ascii.delimiter)));
|
|
kCheck(kXml_SetChildText(xml, tempItem, "Terminator", kString_Chars(obj->ascii.terminator)));
|
|
kCheck(kXml_SetChildText(xml, tempItem, "InvalidValue", kString_Chars(obj->ascii.invalidValue)));
|
|
kCheck(kXml_SetChildText(xml, tempItem, "CustomDataFormat", kString_Chars(obj->ascii.customFormat)));
|
|
kCheck(kXml_SetChildBool(xml, tempItem, "CustomFormatEnabled", obj->ascii.customFormatEnabled));
|
|
kCheck(kXml_SetChild32s(xml, tempItem, "StandardFormatMode", obj->ascii.standardFormatMode));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ReadEip(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
tempItem = kXml_Child(xml, item, "EIP");
|
|
if (!kIsNull(tempItem))
|
|
{
|
|
kCheck(kXml_ChildBool(xml, tempItem, "BufferEnabled", &obj->eip.bufferEnabled));
|
|
kCheck(GoConfig_Read32sOptional(xml, tempItem, "EndianOutputType", kFALSE, &obj->eip.endianOutputType));
|
|
kCheck(GoConfig_ReadBoolOptional(xml, tempItem, "ImplicitOutputEnabled", kFALSE, &obj->eip.implicitOutputEnabled));
|
|
kCheck(GoConfig_Read32sOptional(xml, tempItem, "ImplicitTriggerOverride", kFALSE, &obj->eip.implicitTriggerOverride));
|
|
}
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_WriteEip(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
kCheck(kXml_AddItem(xml, item, "EIP", &tempItem));
|
|
kCheck(kXml_SetChildBool(xml, tempItem, "BufferEnabled", obj->eip.bufferEnabled));
|
|
kCheck(kXml_SetChild32s(xml, tempItem, "EndianOutputType", obj->eip.endianOutputType));
|
|
kCheck(kXml_SetChildBool(xml, tempItem, "ImplicitOutputEnabled", obj->eip.implicitOutputEnabled));
|
|
kCheck(kXml_SetChild32s(xml, tempItem, "ImplicitTriggerOverride", obj->eip.implicitTriggerOverride));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ReadModbus(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
tempItem = kXml_Child(xml, item, "Modbus");
|
|
if (!kIsNull(tempItem))
|
|
{
|
|
kCheck(kXml_ChildBool(xml, tempItem, "BufferEnabled", &obj->modbus.bufferEnabled));
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_WriteModbus(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
|
|
kCheck(kXml_AddItem(xml, item, "Modbus", &tempItem));
|
|
kCheck(kXml_SetChildBool(xml, tempItem, "BufferEnabled", obj->modbus.bufferEnabled));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ReadProfinet(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
kString tempString = kNULL;
|
|
kStatus exception;
|
|
|
|
tempItem = kXml_Child(xml, item, "Profinet");
|
|
if (!kIsNull(tempItem))
|
|
{
|
|
kTry
|
|
{
|
|
kTest(kString_Construct(&tempString, "", kObject_Alloc(ethernet)));
|
|
|
|
kTest(kXml_ChildString(xml, tempItem, "IpAddress", tempString));
|
|
kTest(kIpAddress_Parse(&obj->profinet.ipAddress, kString_Chars(tempString)));
|
|
|
|
kTest(kXml_ChildString(xml, tempItem, "SubnetMask", tempString));
|
|
kTest(kIpAddress_Parse(&obj->profinet.subnetMask, kString_Chars(tempString)));
|
|
|
|
kTest(kXml_ChildString(xml, tempItem, "Gateway", tempString));
|
|
kTest(kIpAddress_Parse(&obj->profinet.gateway, kString_Chars(tempString)));
|
|
|
|
kTest(kXml_ChildString(xml, tempItem, "DeviceName", obj->profinet.deviceName));
|
|
}
|
|
kCatchEx(&exception)
|
|
{
|
|
kLogf("%s: error %d reading Profinet configuration", __FUNCTION__, exception);
|
|
|
|
kEndCatchEx(exception);
|
|
}
|
|
kFinallyEx
|
|
{
|
|
kCheck(kObject_Destroy(tempString));
|
|
|
|
kEndFinallyEx();
|
|
}
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ReadPtp(GoEthernet ethernet, kXml xml, kXmlItem item)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kXmlItem tempItem = kNULL;
|
|
kString tempString = kNULL;
|
|
kStatus exception;
|
|
|
|
tempItem = kXml_Child(xml, item, "Ptp");
|
|
if (!kIsNull(tempItem))
|
|
{
|
|
kTry
|
|
{
|
|
kTest(kString_Construct(&tempString, "", kObject_Alloc(ethernet)));
|
|
}
|
|
kCatchEx(&exception)
|
|
{
|
|
kLogf("%s: error %d reading Ptp configuration", __FUNCTION__, exception);
|
|
|
|
kEndCatchEx(exception);
|
|
}
|
|
kFinallyEx
|
|
{
|
|
kCheck(kObject_Destroy(tempString));
|
|
|
|
kEndFinallyEx();
|
|
}
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ParseHelperComposite(const kChar* text, kSize length, GoOutputCompositeSource* value)
|
|
{
|
|
const kChar* readIt = text;
|
|
const kChar* separator = kNULL;
|
|
|
|
if (length == 0)
|
|
{
|
|
return kERROR_PARAMETER;
|
|
}
|
|
|
|
if (!kIsNull(separator = strchr(readIt, GO_UTILS_STREAM_ID_SEPARATOR)))
|
|
{
|
|
if (kSuccess(GoOptionList_ParseHelper32s(readIt, separator - readIt, &value->id)))
|
|
{
|
|
readIt = separator + 1;
|
|
if (kSuccess(GoOptionList_ParseHelper32s(readIt, separator - readIt, &value->dataSource)))
|
|
{
|
|
return kOK;
|
|
}
|
|
}
|
|
}
|
|
|
|
return kERROR_CONFLICT;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ParseCompositeOptionList(const kChar* text, kArrayList list)
|
|
{
|
|
const kChar* readIt = text;
|
|
const kChar* separator = kNULL;
|
|
GoOutputCompositeSource option;
|
|
|
|
kCheck(kArrayList_Clear(list));
|
|
kCheck(kArrayList_Allocate(list, kTypeOf(GoOutputCompositeSource), 0));
|
|
|
|
while (!kIsNull(separator = strchr(readIt, ',')))
|
|
{
|
|
if (kSuccess(GoEthernet_ParseHelperComposite(readIt, separator - readIt, &option)))
|
|
{
|
|
kCheck(kArrayList_AddT(list, &option));
|
|
}
|
|
readIt = separator + 1;
|
|
}
|
|
|
|
if (kSuccess(GoEthernet_ParseHelperComposite(readIt, strlen(readIt), &option)))
|
|
{
|
|
kCheck(kArrayList_AddT(list, &option));
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kBool) GoEthernet_CheckCompositeSource(const GoOutputCompositeSource* optionList, kSize count, GoOutputCompositeSource value)
|
|
{
|
|
kSize i;
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
if (optionList[i].id == value.id && optionList[i].dataSource == value.dataSource)
|
|
{
|
|
return kTRUE;
|
|
}
|
|
}
|
|
|
|
return kFALSE;
|
|
}
|
|
|
|
GoFx(kArrayList) GoEthernet_OptionList(GoEthernet ethernet, GoOutputSource type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
|
|
switch (type)
|
|
{
|
|
case GO_OUTPUT_SOURCE_VIDEO: list = obj->videoOptions; break;
|
|
case GO_OUTPUT_SOURCE_RANGE: list = obj->rangeOptions; break;
|
|
case GO_OUTPUT_SOURCE_RANGE_INTENSITY: list = obj->rangeIntensityOptions; break;
|
|
case GO_OUTPUT_SOURCE_PROFILE: list = obj->profileOptions; break;
|
|
case GO_OUTPUT_SOURCE_PROFILE_INTENSITY: list = obj->profileIntensityOptions; break;
|
|
case GO_OUTPUT_SOURCE_SURFACE: list = obj->surfaceOptions; break;
|
|
case GO_OUTPUT_SOURCE_SURFACE_INTENSITY: list = obj->surfaceIntensityOptions; break;
|
|
case GO_OUTPUT_SOURCE_SECTION: list = obj->sectionOptions; break;
|
|
case GO_OUTPUT_SOURCE_SECTION_INTENSITY: list = obj->sectionIntensityOptions; break;
|
|
case GO_OUTPUT_SOURCE_MEASUREMENT: list = obj->measurementOptions; break;
|
|
case GO_OUTPUT_SOURCE_TRACHEID: list = obj->tracheidOptions; break;
|
|
case GO_OUTPUT_SOURCE_EVENT: list = obj->eventOptions; break;
|
|
case GO_OUTPUT_SOURCE_FEATURE: list = obj->featureOptions; break;
|
|
case GO_OUTPUT_SOURCE_TOOLDATA: list = obj->toolDataOptions; break;
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
GoFx(kArrayList) GoEthernet_SourceList(GoEthernet ethernet, GoOutputSource type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
|
|
switch (type)
|
|
{
|
|
case GO_OUTPUT_SOURCE_VIDEO: list = obj->videoSources; break;
|
|
case GO_OUTPUT_SOURCE_RANGE: list = obj->rangeSources; break;
|
|
case GO_OUTPUT_SOURCE_RANGE_INTENSITY: list = obj->rangeIntensitySources; break;
|
|
case GO_OUTPUT_SOURCE_PROFILE: list = obj->profileSources; break;
|
|
case GO_OUTPUT_SOURCE_PROFILE_INTENSITY: list = obj->profileIntensitySources; break;
|
|
case GO_OUTPUT_SOURCE_SURFACE: list = obj->surfaceSources; break;
|
|
case GO_OUTPUT_SOURCE_SURFACE_INTENSITY: list = obj->surfaceIntensitySources; break;
|
|
case GO_OUTPUT_SOURCE_SECTION: list = obj->sectionSources; break;
|
|
case GO_OUTPUT_SOURCE_SECTION_INTENSITY: list = obj->sectionIntensitySources; break;
|
|
case GO_OUTPUT_SOURCE_MEASUREMENT: list = obj->measurementSources; break;
|
|
case GO_OUTPUT_SOURCE_TRACHEID: list = obj->tracheidSources; break;
|
|
case GO_OUTPUT_SOURCE_EVENT: list = obj->events; break;
|
|
case GO_OUTPUT_SOURCE_FEATURE: list = obj->featureSources; break;
|
|
case GO_OUTPUT_SOURCE_TOOLDATA: list = obj->toolDataSources; break;
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
GoFx(kSize) GoEthernet_OptionCount(GoEthernet ethernet, GoOutputSource type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
list = GoEthernet_OptionList(ethernet, type);
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return kArrayList_Count(list);
|
|
}
|
|
|
|
GoFx(k32u) GoEthernet_OptionAt(GoEthernet ethernet, GoOutputSource type, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
list = GoEthernet_OptionList(ethernet, type);
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
kAssert(index < kArrayList_Count(list));
|
|
|
|
return kArrayList_AsT(list, index, k32u);
|
|
}
|
|
|
|
GoFx(kSize) GoEthernet_SourceCount(GoEthernet ethernet, GoOutputSource type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
list = GoEthernet_SourceList(ethernet, type);
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return kArrayList_Count(list);
|
|
}
|
|
|
|
GoFx(k32u) GoEthernet_SourceAt(GoEthernet ethernet, GoOutputSource type, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
list = GoEthernet_SourceList(ethernet, type);
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
kAssert(index < kArrayList_Count(list));
|
|
|
|
return kArrayList_AsT(list, index, k32u);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_AddSource(GoEthernet ethernet, GoOutputSource type, k32s sourceId)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
kArrayList optionList = kNULL;
|
|
|
|
kCheck(GoSensor_SyncConfig(obj->sensor));
|
|
|
|
|
|
// Section and Section Intensity:
|
|
// - GoEthernet_RemoveCompositeSource must be used for sections.
|
|
if ((type != GO_OUTPUT_SOURCE_SECTION) &&
|
|
(type != GO_OUTPUT_SOURCE_SECTION_INTENSITY))
|
|
{
|
|
list = GoEthernet_SourceList(ethernet, type);
|
|
optionList = GoEthernet_OptionList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list) || kIsNull(optionList))
|
|
{
|
|
return kERROR_PARAMETER;
|
|
}
|
|
|
|
kCheckArgs(GoOptionList_Check32s(kArrayList_DataT(optionList, const k32s), kArrayList_Count(optionList), sourceId));
|
|
kCheck(kArrayList_AddT(list, &sourceId));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_RemoveSource(GoEthernet ethernet, GoOutputSource type, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
|
|
kCheck(GoSensor_SyncConfig(obj->sensor));
|
|
|
|
// Section and Section Intensity:
|
|
// - GoEthernet_RemoveCompositeSource must be used for sections.
|
|
// Event:
|
|
// - Use the event specific APIs to add and remove events.
|
|
if ((type != GO_OUTPUT_SOURCE_EVENT) &&
|
|
(type != GO_OUTPUT_SOURCE_SECTION) &&
|
|
(type != GO_OUTPUT_SOURCE_SECTION_INTENSITY))
|
|
{
|
|
list = GoEthernet_SourceList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return kERROR_PARAMETER;
|
|
}
|
|
|
|
kCheck(kArrayList_Discard(list, index));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kSize) GoEthernet_CompositeOptionCount(GoEthernet ethernet, GoOutputSource type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
if (type == GO_OUTPUT_SOURCE_SECTION ||
|
|
type == GO_OUTPUT_SOURCE_SECTION_INTENSITY)
|
|
{
|
|
list = GoEthernet_OptionList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return kArrayList_Count(list);
|
|
}
|
|
|
|
GoFx(GoOutputCompositeSource) GoEthernet_CompositeOptionAt(GoEthernet ethernet, GoOutputSource type, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
GoOutputCompositeSource failedSearch;
|
|
|
|
failedSearch.id = -1;
|
|
failedSearch.dataSource = GO_DATA_SOURCE_NONE;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
if (type == GO_OUTPUT_SOURCE_SECTION ||
|
|
type == GO_OUTPUT_SOURCE_SECTION_INTENSITY)
|
|
{
|
|
list = GoEthernet_OptionList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return failedSearch;
|
|
}
|
|
|
|
kAssert(index < kArrayList_Count(list));
|
|
|
|
return kArrayList_AsT(list, index, GoOutputCompositeSource);
|
|
}
|
|
|
|
GoFx(kSize) GoEthernet_CompositeSourceCount(GoEthernet ethernet, GoOutputSource type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
if (type == GO_OUTPUT_SOURCE_SECTION ||
|
|
type == GO_OUTPUT_SOURCE_SECTION_INTENSITY)
|
|
{
|
|
list = GoEthernet_OptionList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return kArrayList_Count(list);
|
|
}
|
|
|
|
GoFx(GoOutputCompositeSource) GoEthernet_CompositeSourceAt(GoEthernet ethernet, GoOutputSource type, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
GoOutputCompositeSource failedSearch;
|
|
|
|
failedSearch.id = -1;
|
|
failedSearch.dataSource = GO_DATA_SOURCE_NONE;
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
if (type == GO_OUTPUT_SOURCE_SECTION ||
|
|
type == GO_OUTPUT_SOURCE_SECTION_INTENSITY)
|
|
{
|
|
list = GoEthernet_OptionList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return failedSearch;
|
|
}
|
|
|
|
kAssert(index < kArrayList_Count(list));
|
|
|
|
return kArrayList_AsT(list, index, GoOutputCompositeSource);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_AddCompositeSource(GoEthernet ethernet, GoOutputSource type, GoOutputCompositeSource option)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
kArrayList optionList = kNULL;
|
|
|
|
kCheck(GoSensor_SyncConfig(obj->sensor));
|
|
|
|
if (type == GO_OUTPUT_SOURCE_SECTION ||
|
|
type == GO_OUTPUT_SOURCE_SECTION_INTENSITY)
|
|
{
|
|
list = GoEthernet_SourceList(ethernet, type);
|
|
optionList = GoEthernet_OptionList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list) || kIsNull(optionList))
|
|
{
|
|
return kERROR_PARAMETER;
|
|
}
|
|
|
|
kCheck(GoEthernet_CheckCompositeSource(kArrayList_DataT(optionList, const GoOutputCompositeSource), kArrayList_Count(optionList), option));
|
|
kCheck(kArrayList_AddT(list, &option));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_RemoveCompositeSource(GoEthernet ethernet, GoOutputSource type, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list = kNULL;
|
|
|
|
kCheck(GoSensor_SyncConfig(obj->sensor));
|
|
|
|
if (type == GO_OUTPUT_SOURCE_SECTION ||
|
|
type == GO_OUTPUT_SOURCE_SECTION_INTENSITY)
|
|
{
|
|
list = GoEthernet_SourceList(ethernet, type);
|
|
}
|
|
|
|
if (kIsNull(list))
|
|
{
|
|
return kERROR_PARAMETER;
|
|
}
|
|
|
|
kCheck(kArrayList_Discard(list, index));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
|
|
GoFx(kStatus) GoEthernet_ClearAllSources(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kSize i;
|
|
kSize numMapEntry = kCountOf(g_EthernetOutputSourceTypeMap);
|
|
|
|
kCheck(GoSensor_SyncConfig(obj->sensor));
|
|
|
|
for (i = 0; i < numMapEntry; i++)
|
|
{
|
|
kCheck(GoEthernet_ClearSources(ethernet, (GoOutputSource) g_EthernetOutputSourceTypeMap[i].value));
|
|
}
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ClearSources(GoEthernet ethernet, GoOutputSource type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
kArrayList list;
|
|
|
|
list = GoEthernet_SourceList(ethernet, type);
|
|
if (kIsNull(list))
|
|
{
|
|
return kERROR_PARAMETER;
|
|
}
|
|
|
|
kCheck(kArrayList_Clear(list));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
|
|
GoFx(k64f) GoEthernet_Timeout(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->timeout;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetTimeout(GoEthernet ethernet, k64f value)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheckArgs(value >= 0.0);
|
|
|
|
obj->timeout = value;
|
|
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kBool) GoEthernet_TimeoutEnabled(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->timeoutEnabled;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_EnableTimeout(GoEthernet ethernet, kBool value)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->timeoutEnabled = value;
|
|
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kBool) GoEthernet_TimeoutEnabledIsAvailable(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->timeoutEnabledAvail;
|
|
}
|
|
|
|
GoFx(GoEthernetProtocol) GoEthernet_Protocol(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->protocol;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetProtocol(GoEthernet ethernet, GoEthernetProtocol protocol)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->protocol = protocol;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(GoAsciiOperation) GoEthernet_AsciiOperation(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->ascii.operation;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiOperation(GoEthernet ethernet, GoAsciiOperation mode)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->ascii.operation = mode;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(k32u) GoEthernet_AsciiControlPort(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->ascii.controlPort;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiControlPort(GoEthernet ethernet, k32u port)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->ascii.controlPort = port;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(k32u) GoEthernet_AsciiHealthPort(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->ascii.healthPort;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiHealthPort(GoEthernet ethernet, k32u port)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->ascii.healthPort = port;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(k32u) GoEthernet_AsciiDataPort(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->ascii.dataPort;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiDataPort(GoEthernet ethernet, k32u port)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->ascii.dataPort = port;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kChar*) GoEthernet_AsciiDelimiter(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return kString_Chars(obj->ascii.delimiter);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiDelimiter(GoEthernet ethernet, const kChar* string)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheck(kString_Set(obj->ascii.delimiter, string));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kChar*) GoEthernet_AsciiTerminator(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return kString_Chars(obj->ascii.terminator);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiTerminator(GoEthernet ethernet, const kChar* string)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheck(kString_Set(obj->ascii.terminator, string));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kChar*) GoEthernet_AsciiInvalidValue(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return kString_Chars(obj->ascii.invalidValue);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiInvalidValue(GoEthernet ethernet, const kChar* string)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheck(kString_Set(obj->ascii.invalidValue, string));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kChar*) GoEthernet_AsciiCustomDataFormat(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return kString_Chars(obj->ascii.customFormat);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiCustomDataFormat(GoEthernet ethernet, const kChar* string)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheck(kString_Set(obj->ascii.customFormat, string));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_EnableAsciiCustomFormat(GoEthernet ethernet, kBool enabled)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->ascii.customFormatEnabled = enabled;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kBool) GoEthernet_AsciiCustomFormatEnabled(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->ascii.customFormatEnabled;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetAsciiStandardFormat(GoEthernet ethernet, GoAsciiStandardFormatMode mode)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->ascii.standardFormatMode = mode;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(GoAsciiStandardFormatMode) GoEthernet_AsciiStandardFormat(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->ascii.standardFormatMode;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetEIPBufferingEnabled(GoEthernet ethernet, kBool enabled)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->eip.bufferEnabled = enabled;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kBool) GoEthernet_EIPBufferingEnabled(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->eip.bufferEnabled;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetEIPImplicitOutputEnabled(GoEthernet ethernet, kBool enabled)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->eip.implicitOutputEnabled = enabled;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kBool) GoEthernet_EIPImplicitOutputEnabled(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->eip.implicitOutputEnabled;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetEIPEndianOutputType(GoEthernet ethernet, GoEndianType type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->eip.endianOutputType = type;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(GoEndianType) GoEthernet_EIPEndianOutputType(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->eip.endianOutputType;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_SetEIPImplicitTriggerOverride(GoEthernet ethernet, GoImplicitTriggerOverride value)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->eip.implicitTriggerOverride = value;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(GoImplicitTriggerOverride) GoEthernet_EIPImplicitTriggerOverride(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->eip.implicitTriggerOverride;
|
|
}
|
|
|
|
|
|
GoFx(kStatus) GoEthernet_SetModbusBufferingEnabled(GoEthernet ethernet, kBool enabled)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
obj->modbus.bufferEnabled = enabled;
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kBool) GoEthernet_ModbusBufferingEnabled(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return obj->modbus.bufferEnabled;
|
|
}
|
|
|
|
GoFx(const kIpAddress*) GoEthernet_ProfinetIpAddress(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return (const kIpAddress*) &obj->profinet.ipAddress;
|
|
}
|
|
|
|
GoFx(const kIpAddress*) GoEthernet_ProfinetSubnetMask(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return (const kIpAddress*) &obj->profinet.subnetMask;
|
|
}
|
|
|
|
GoFx(const kIpAddress*) GoEthernet_ProfinetGateway(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return (const kIpAddress*) &obj->profinet.gateway;
|
|
}
|
|
|
|
GoFx(const kChar*) GoEthernet_ProfinetDeviceName(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
GoSensor_SyncConfig(obj->sensor);
|
|
|
|
return (const kChar*) kString_Chars(obj->profinet.deviceName);
|
|
}
|
|
|
|
GoFx(kSize) GoEthernet_EventOptionCount(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
return kArrayList_Count(obj->eventOptions);
|
|
}
|
|
|
|
GoFx(GoEventType) GoEthernet_EventOptionAt(GoEthernet ethernet, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kAssert(index < kArrayList_Count(obj->eventOptions));
|
|
|
|
return *kArrayList_AtT(obj->eventOptions, index, GoEventType);
|
|
}
|
|
|
|
GoFx(kSize) GoEthernet_EventCount(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
return kArrayList_Count(obj->events);
|
|
}
|
|
|
|
GoFx(GoEventType) GoEthernet_EventAt(GoEthernet ethernet, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kAssert(index < kArrayList_Count(obj->events));
|
|
|
|
return *kArrayList_AtT(obj->events, index, GoEventType);
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_AddEvent(GoEthernet ethernet, GoEventType type)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheck(kArrayList_AddT(obj->events, &type));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_RemoveEvent(GoEthernet ethernet, kSize index)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kAssert(index < kArrayList_Count(obj->eventOptions));
|
|
kCheck(kArrayList_Discard(obj->eventOptions, index));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|
|
|
|
GoFx(kStatus) GoEthernet_ClearEvents(GoEthernet ethernet)
|
|
{
|
|
kObj(GoEthernet, ethernet);
|
|
|
|
kCheck(kArrayList_Clear(obj->events));
|
|
kCheck(GoSensor_SetConfigModified(obj->sensor));
|
|
|
|
return kOK;
|
|
}
|