private void BuildEdmMap(EdmCapability edmCapability)
{
foreach (var definition in edmCapability.AttributeDefinitions)
{
_guidUicAttributeMap.Add(definition.Uri, definition);
if (definition.Id == new Guid("(b68df3f9-4748-4c9d-9bda-567c87fab855)"))
{
_guidUicAttributeMap.Add("Id", definition);
}
}
foreach (var definition in edmCapability.DatapointDefinitions)
{
_guidUicDatapointMap.Add(definition.Uri, definition);
if (definition.Id == new Guid("{83f02bea-c22b-46aa-b1c2-4ab8102d8a80}"))
{
_guidUicDatapointMap.Add("bool_mock", definition);
}
else if (definition.Id == new Guid("{4087d40d-d4e2-42b1-89a4-9b9d18499a04}"))
{
_guidUicDatapointMap.Add("int_mock", definition);
}
else if (definition.Id == new Guid("{a41fc3af-4f73-42bf-8290-43ed883edd8f}"))
{
_guidUicDatapointMap.Add("double_mock", definition);
}
else if (definition.Id == new Guid("{fbd3e390-ffb7-455b-b0dc-695b13329eb6}"))
{
_guidUicDatapointMap.Add("string_mock", definition);
}
}
}
public EapiI2cEdm(ILoggerFactory loggerFactory)
{
Identifier = new EapiI2cEdmIdentifier(GetType().FullName);
_eapiInitializer = new EapiInitializer();
_i2CDriver = new I2cDriver(loggerFactory.GetLoggerFor(typeof(I2cDriver)), new EApiStatusCodes());
_edmCapability = CreateEdmCapability();
}
public void Initialize()
{
_eapiInitializer.Init();
var gpioCapabilities = _gpioDriver.GetGpioCapabilities();
_edmCapability = CreateEdmCapability();
Test(gpioCapabilities);
}
public EapiBoardInformationEdmCapabilityProvider(EmbeddedDriverModule edm)
{
_edm = edm;
List <CommandDefinition> commandDefinitions = GetCommands();
List <AttributeDefinition> attribtueDefinitions = GetAttributeDefinitions();
List <DatapointDefinition> datapointDefinitions = GetDatapointDefinitions();
EdmCapability = new EapiBoardInformationEdmCapability(_edm.Identifier, commandDefinitions.ToArray(), attribtueDefinitions.ToArray(), datapointDefinitions.ToArray());
}
public Vcnl4010Edm(ILoggerFactory loggerFactory)
{
_loggerFactory = loggerFactory;
Identifier = new Vcnl4010Identifier();
_edmCapability = CreateEdmCapability();
_edmCapability = CreateEdmCapability();
}
public RebootEdm(ILoggerFactory loggerFactory)
{
_logger = loggerFactory.GetLoggerFor(GetType());
Identifier = new RebootEdmIdentifier(GetType().FullName);
_rebootCommnand = new SgetCommandDefinition(new Guid("{f54b990d-25f5-430d-8428-44ab74ed8509}"), UicUriBuilder.CommandFrom(this, "reboot"), "Reboot System", "reboot", UicDataType.String, "Reboots the system", null, null);
CommandDefinition[] commandDefinitios =
{
_rebootCommnand
};
AttributeDefinition[] attribtueDefinitions = new AttributeDefinition[0];
DatapointDefinition[] datapointDefinitions = new DatapointDefinition[0];
_edmCapability = new RebootEdmEdmCapability(Identifier, commandDefinitios, attribtueDefinitions, datapointDefinitions);
}
private void BuildEdmMap(EmbeddedDriverModule edm, EdmCapability edmCapability)
{
foreach (var definition in edmCapability.AttributeDefinitions)
{
_definitionEdmMap.Add(definition.Id, edm);
}
foreach (var definition in edmCapability.DatapointDefinitions)
{
_definitionEdmMap.Add(definition.Id, edm);
}
foreach (var definition in edmCapability.CommandDefinitions)
{
_definitionEdmMap.Add(definition.Id, edm);
}
}
public SgetEmbeddedDriverModuleAppliance Translate(EdmCapability edmCapability)
{
var cloudMapperIdentifier = new CloudMapperIdentifier(new Guid("9D368ED2-075F-4348-831E-D2CEA97E881A"), "SgetUicProjectTranlator");
var embeddedModuleIdentifier = new EmbeddedModuleIdentifier(edmCapability.Identifier.Id, edmCapability.Identifier.Uri);
var interfaceIdentifier = new EmbeddedHwInterfaceIdentifier(embeddedModuleIdentifier.Id, embeddedModuleIdentifier.Name);
var attributes = Translate(edmCapability.AttributeDefinitions, interfaceIdentifier);
var dataPoints = Translate(edmCapability.DatapointDefinitions, interfaceIdentifier);
var commands = Translate(edmCapability.CommandDefinitions, interfaceIdentifier, dataPoints);
var embeddedModuleHwInterfaceCapability = new EmbeddedModuleHwInterfaceCapability(interfaceIdentifier, attributes, dataPoints, commands);
var interfaces = new List <EmbeddedModuleHwInterfaceCapability> {
embeddedModuleHwInterfaceCapability
};
var embeddedDriverModulCapabilitiy = new EmbeddedDriverModulCapabilitiy(embeddedModuleIdentifier, interfaces);
return(new SgetEmbeddedDriverModuleAppliance(cloudMapperIdentifier, new [] { embeddedDriverModulCapabilitiy }));
}
public void Initialize(EmbeddedDriverModule[] embeddedDriverModules)
{
_initializedEDMs = new List <EmbeddedDriverModule>();
_logger.Information("Initialize");
foreach (EmbeddedDriverModule edm in embeddedDriverModules)
{
try
{
edm.Initialize();
EdmCapability edmCapability = edm.GetCapability();
BuildEdmMap(edm, edmCapability);
_initializedEDMs.Add(edm);
}
catch (Exception e)
{
_logger.Error(e, $"Initializating of EDM {edm.Identifier.Uri} failed");
}
}
_projectAgent.Initialize(_initializedEDMs.ToArray());
if (_uicConfiguartion.IsEdmSnychronizationEnabled)
{
foreach (EmbeddedDriverModule edm in _initializedEDMs)
{
_projectAgent.Synchronize(edm.GetCapability());
}
}
UicProject project = LoadUicProject();
SerialId = GernerateApplianceSerialKey(project);
_communicationAgent.Initialize(SerialId, project, _initializedEDMs);
_communicationAgent.Connect(CloudAgentCommandHandler);
PushAttributeValues(project);
StartDatapointMonitoring(project);
}
private void BuildEdmMap(EdmCapability edmCapability)
{
foreach (var command in edmCapability.CommandDefinitions)
{
_guidUicCommandMap.Add(command.Id, command);
if (command.RelatedDatapoint != null)
{
List <CommandDefinition> commandList;
if (_guidUicSensorCommandMap.TryGetValue(command.RelatedDatapoint.Id, out commandList))
{
commandList.Add(command);
}
else
{
_guidUicSensorCommandMap.Add(command.RelatedDatapoint.Id, new List <CommandDefinition> {
command
});
}
}
}
}
public void Startup()
{
_uicConfiguartion = uicConfiguartionProvider.GetUicConfiguartion();
string serialId = "extract serial Id of the embedded device as asset identifier for the cloud applicaiton";
foreach (EmbeddedDriverModule edm in _uicConfiguartion.EmbeddedDriverModulesToLoad)
{
edm.Initialize();
}
if (_uicConfiguartion.IsEdmSnychronizationEnabled)
{
foreach (EmbeddedDriverModule edm in _uicConfiguartion.EmbeddedDriverModulesToLoad)
{
EdmCapability edmCapability = edm.GetCapability();
// Synchronize edm with edm and project cloud
}
}
UicProject project = null;
if (_uicConfiguartion.IsRemoteProjectLoadingEnabled)
{
//Url EdmSnychronizationUrl { get; }
//Url RemoteProjectConfigurationUrl();
//var projectConfigurationUrl = _uicConfiguartion.RemoteProjectConfigurationUrl();
//project = LoadProjectFromRemote(projectConfigurationUrl);
}
else
{
var serializedProjectFilepath = _uicConfiguartion.AbsoluteProjectConfigurationFilePath;
project = LoadProjectFromFile(serializedProjectFilepath);
}
_communicationAgent.Synchronize(serialId, project);
_communicationAgent.Connect(CloudAgentCommandHandler);
// read and publish
foreach (var attribtueDefinition in project.Attributes)
{
EmbeddedDriverModule edm = GetEdmFor(attribtueDefinition);
AttributeValue attibutValue = edm.GetValueFor(attribtueDefinition);
_communicationAgent.Push(attibutValue);
//Set Asynchronous EDM Calbbacks if necessary
edm.SetAttributeCallback(attribtueDefinition, attributeValue => _communicationAgent.Push(attributeValue));
}
foreach (ProjectDatapointTask datapointTask in project.DatapointTasks)
{
EmbeddedDriverModule edm = GetEdmFor(datapointTask.Definition);
//start Monitoring the DatapointTasks from the project
StartDatapointMonitoring(datapointTask.Definition, datapointTask.PollIntervall,
datapointTask.ReportingCondition, edm);
//Set Asynchronous EDM Calbbacks if necessary
edm.SetDatapointCallback(datapointTask, datapointValue => _communicationAgent.Push(datapointValue));
}
}
public void Synchronize(EdmCapability edmCapability)
{
SgetEmbeddedDriverModuleAppliance appliance = _projectTranslator.Translate(edmCapability);
_projectCloudWebApiWrapper.SynchronizeEmbeddedModuleFunctions(_configuration, appliance);
}
public void Synchronize(EdmCapability edmCapability)
{
}
public EDMWrapper(UIC.Framework.Interfaces.Edm.EmbeddedDriverModule element)
{
identifier = element.Identifier;
capability = element.GetCapability();
}
