public static string ModuleHeader(IEnumerable <Event> events, IEnumerable <Variable> variables, string fbTypeName)
{
string outp = "";
outp += FbSmvCommon.SmvModuleDeclaration(events, variables, fbTypeName);
foreach (var variable in variables)
{
if (variable.ArraySize == 0)
{
if (variable.IsConstant)
{
outp += String.Format(Smv.DefineBlock, variable.Name, variable.InitialValue);
}
else
{
outp += String.Format(Smv.VarDeclarationBlock, variable.Name, variable.SmvType);
}
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
if (variable.IsConstant)
{
outp += String.Format(Smv.VarDeclarationBlock, variable.Name + Smv.ArrayIndex(i), variable.InitialValue); //TODO: parse initial values for arrays
}
else
{
outp += String.Format(Smv.VarDeclarationBlock, variable.Name + Smv.ArrayIndex(i), variable.SmvType);
}
}
}
}
return(outp);
}
private string emptyFbModule(string moduleName)
{
string smvModule = "";
smvModule += FbSmvCommon.SmvModuleDeclaration(new List <Event>(), new List <Variable>(), moduleName);
smvModule += FbSmvCommon.ModuleFooter(_settings) + "\n";
return(smvModule);
}
public static string BasicModuleDefines(IEnumerable <ECState> states, IEnumerable <Event> events, IEnumerable <ECTransition> transitions, bool showUnconditionalTransitions)
{
string ecTran = "";
foreach (ECState state in states)
{
IEnumerable <ECTransition> stateTrans = transitions.Where(t => t.Source == state.Name);
if (!stateTrans.Any())
{
continue;
}
ecTran += "(";
ecTran += Smv.EccStateVar + "=" + Smv.EccState(state.Name);
string transitionRules = "";
foreach (var transition in stateTrans)
{
transitionRules += "(";
if (transition.Condition == null || transition.Condition == "1")
{
if (!showUnconditionalTransitions)
{
transitionRules = null;
break;
}
else
{
transitionRules += "1";
}
}
else
{
transitionRules += _translateEventNames(Smv.ClearConditionExpr(transition.Condition), events);
}
transitionRules += ") | ";
}
if (transitionRules != null)
{
ecTran += " & (" + transitionRules.TrimEnd(Smv.OrTrimChars) + ")";
}
ecTran += ") | ";
}
string existsEnabledECTran = String.Format("DEFINE {0}:= {1};\n", Smv.ExistsEnabledEcTran, ecTran.Trim(Smv.OrTrimChars));
string absentsEnabledECTran = "\n";
//string alphabeta = "--alpha/beta\nDEFINE alpha_beta := ( (alpha & S_smv=s0_osm & !ExistsInputEvent | S_smv=s1_osm & (!ExistsEnabledECTran)) );\n";
return(FbSmvCommon.DefineExistsInputEvent(events) + existsEnabledECTran + absentsEnabledECTran); // + alphabeta;
}
public string TranslateCompositeFB(FBType fbType)
{
string smvModule = "";
ExecutionModel executionModel = _executionModels.FirstOrDefault(em => em.FBTypeName == fbType.Name);
var events = _storage.Events.Where(ev => ev.FBType == fbType.Name);
var variables = _storage.Variables.Where(ev => ev.FBType == fbType.Name);
var instances = _storage.Instances.Where(inst => inst.FBType == fbType.Name);
var withConnections = _storage.WithConnections.Where(conn => conn.FBType == fbType.Name);
var connections = _storage.Connections.Where(conn => conn.FBType == fbType.Name);
var instanceParameters = _storage.InstanceParameters.Where(p => p.FBType == fbType.Name);
IDispatcher dispatcher = executionModel.Dispatcher;
//smvModule += _moduleHeader(events, variables, fbType.Name) + "\n";
smvModule += FbSmvCommon.SmvModuleDeclaration(events, variables, fbType.Name);
smvModule += CompositeFbSmv.FbInstances(instances, _storage.Events, _storage.Variables, connections, _settings) + "\n";
smvModule += CompositeFbSmv.InternalBuffersDeclaration(instances, connections, _storage.Events, _storage.Variables) + "\n";
smvModule += Smv.Assign;
smvModule += CompositeFbSmv.InternalBuffersInitialization(instances, connections, _storage.Events, _storage.Variables, instanceParameters) + "\n";
if (_settings.UseProcesses)
{
smvModule += CompositeFbSmv.NonConnectedInstanceOutputEvents(_storage.Events, instances, connections);
smvModule += CompositeFbSmv.ComponentDataOutputNextStatements(_storage.Variables, instances);
}
//smvModule += _moduleVariablesInitBlock(variables) + "\n";
//smvModule += _inputVariablesSampleComposite(variables, withConnections) + "\n";
smvModule += CompositeFbSmv.NonConnectedEventInputs(connections, _storage.Events, instances, _showMessage);
smvModule += CompositeFbSmv.NonConnectedInputs(connections, _storage.Variables, instances);
smvModule += CompositeFbSmv.InternalDataConnections(connections, withConnections, _storage.Variables, instances) + "\n";
smvModule += CompositeFbSmv.ComponentEventOutputs(connections, _settings.UseProcesses) + "\n";
//smvModule += _eventInputsResetRules(events) + "\n";
smvModule += "\n-- ---DISPATCHER--- --\n";
smvModule += "-- *************** --\n";
smvModule += dispatcher.GetSmvCode(_settings.UseProcesses) + "\n";
smvModule += CompositeFbSmv.InternalEventConnections(connections, _settings.UseProcesses) + "\n";
smvModule += CompositeFbSmv.InputEventsResetRules(events, _settings.UseProcesses);
smvModule += FbSmvCommon.DefineExistsInputEvent(events) + "\n";
smvModule += CompositeFbSmv.DefineOmega(connections) + "\n";
smvModule += CompositeFbSmv.DefinePhi(instances, _storage.Events) + "\n"; //phi variable for timed models
smvModule += FbSmvCommon.ModuleFooter(_settings) + "\n";
//smvModule += Smv.AlphaBetaRules;
return(smvModule);
}
public static string ESplitFBModule(Storage storage, Settings settings)
{
string smvModule = "";
var events = storage.Events.Where(ev => ev.FBType == LibraryTypes.E_SPLIT);
var variables = new List <Variable>();
smvModule += FbSmvCommon.SmvModuleDeclaration(events, variables, LibraryTypes.E_SPLIT);
smvModule += String.Format(Smv.DefineBlock, "event_EI_reset", "event_EI");
smvModule += String.Format(Smv.DefineBlock, "event_EO1_set", "event_EI");
smvModule += String.Format(Smv.DefineBlock, "event_EO2_set", "event_EI");
smvModule += String.Format(Smv.DefineBlock, "alpha_reset", Smv.Alpha);
smvModule += String.Format(Smv.DefineBlock, "beta_set", Smv.Alpha);
smvModule += FbSmvCommon.ModuleFooter(settings) + "\n";
return(smvModule);
}
public string TranslateBasicFB(FBType fbType, bool eventSignalResetSolve = true, bool showUnconditionalTransitions = false)
{
string smvModule = "";
ExecutionModel executionModel = _executionModels.FirstOrDefault(em => em.FBTypeName == fbType.Name);
var events = _storage.Events.Where(ev => ev.FBType == fbType.Name);
var variables = _storage.Variables.Where(ev => ev.FBType == fbType.Name);
var states = _storage.EcStates.Where(ev => ev.FBType == fbType.Name);
var algorithms = _storage.Algorithms.Where(alg => alg.FBType == fbType.Name && alg.Language == AlgorithmLanguages.ST);
var smvAlgs = _translateAlgorithms(algorithms);
var actions = _storage.EcActions.Where(act => act.FBType == fbType.Name);
var withConnections = _storage.WithConnections.Where(conn => conn.FBType == fbType.Name);
var transitions = _storage.EcTransitions.Where(tr => tr.FBType == fbType.Name);
smvModule += BasicFbSmv.ModuleHeader(events, variables, fbType.Name);
smvModule += BasicFbSmv.OsmStatesDeclaration();
smvModule += BasicFbSmv.EccStatesDeclaration(states) + "\n";
smvModule += BasicFbSmv.EcActionsCounterDeclaration(states);
smvModule += BasicFbSmv.AlgStepsCounterDeclaration(smvAlgs);
smvModule += Smv.Assign;
smvModule += String.Format(Smv.VarInitializationBlock, Smv.EccStateVar, Smv.EccState(states.First(s => true).Name));
smvModule += String.Format(Smv.VarInitializationBlock, Smv.OsmStateVar, Smv.Osm.S0);
smvModule += BasicFbSmv.ModuleVariablesInitBlock(variables) + "\n";
smvModule += String.Format(Smv.VarInitializationBlock, Smv.EcActionsCounterVar, "0");
smvModule += String.Format(Smv.VarInitializationBlock, Smv.AlgStepsCounterVar, "0");
smvModule += BasicFbSmv.EcStateChangeBlock(transitions, events);
smvModule += Smv.OsmStateChangeBlock + "\n";
smvModule += BasicFbSmv.EcActionsCounterChangeBlock(states) + "\n";
smvModule += BasicFbSmv.AlgStepsCounterChangeBlock(states, actions, smvAlgs) + "\n";
smvModule += BasicFbSmv.InputVariablesSampleBasic(variables, withConnections) + "\n";
smvModule += BasicFbSmv.OutputVariablesChangingRules(variables, actions, _storage.AlgorithmLines.Where(line => line.FBType == fbType.Name), _settings) + "\n";
smvModule += BasicFbSmv.SetOutputVarBuffers(variables, events, actions, withConnections, _showMessage) + "\n";
smvModule += BasicFbSmv.SetServiceSignals(_settings.UseProcesses) + "\n";
smvModule += BasicFbSmv.EventInputsResetRules(events, executionModel, eventSignalResetSolve, _settings.UseProcesses) + "\n";
smvModule += BasicFbSmv.OutputEventsSettingRules(events, actions, _settings.UseProcesses) + "\n";
smvModule += BasicFbSmv.BasicModuleDefines(states, events, transitions, showUnconditionalTransitions) + "\n";
smvModule += FbSmvCommon.ModuleFooter(_settings) + "\n";
return(smvModule);
}
private static string _timeDelayModule(Storage storage, Settings settings, string fbTypeName, string rule)
{
string smvModule = "";
var events = storage.Events.Where(ev => ev.FBType == fbTypeName);
var variables = storage.Variables.Where(v => v.FBType == fbTypeName);
smvModule += FbSmvCommon.SmvModuleDeclaration(events, variables, fbTypeName);
smvModule += Smv.Assign;
smvModule += String.Format(Smv.VarInitializationBlock, "Do_", "-1");
smvModule += String.Format(Smv.NextCaseBlock, "Do_", rule);
smvModule += String.Format(Smv.DefineBlock, "event_START_reset", Smv.Alpha);
smvModule += String.Format(Smv.DefineBlock, "event_STOP_reset", "(alpha & (event_START))");
smvModule += String.Format(Smv.DefineBlock, "event_EO_set", "(alpha & Di_=0)");
smvModule += String.Format(Smv.DefineBlock, "alpha_reset", Smv.Alpha);
smvModule += String.Format(Smv.DefineBlock, "beta_set", Smv.Alpha);
smvModule += FbSmvCommon.ModuleFooter(settings) + "\n";
return(smvModule);
}
public static string InputVariablesSampleBasic(IEnumerable <Variable> variables, IEnumerable <WithConnection> withConnections)
{
string varChangeBlocks = "";
foreach (Variable variable in variables.Where(v => v.Direction == Direction.Input))
{
if (!variable.IsConstant)
{
if (variable.ArraySize == 0)
{
varChangeBlocks += String.Format(Smv.NextCaseBlock, variable.Name, FbSmvCommon.VarSamplingRule(variable.Name, withConnections, true));
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
varChangeBlocks += String.Format(Smv.NextCaseBlock, variable.Name + Smv.ArrayIndex(i), FbSmvCommon.VarSamplingRule(variable.Name, withConnections, true, i));
}
}
}
}
return(varChangeBlocks);
}
public static string SmvModuleDeclaration(IEnumerable <Event> events, IEnumerable <Variable> variables, string fbTypeName)
{
return(String.Format(Smv.ModuleDef, fbTypeName, FbSmvCommon.ModuleParametersString(events, variables)));
}
public static string InternalDataConnections(IEnumerable <Connection> internalBuffers, IEnumerable <WithConnection> withConnections, IEnumerable <Variable> allVariables, IEnumerable <FBInstance> instances)
{
string dataConnections = "-- _internalDataConnections\n";
foreach (Connection connection in internalBuffers.Where(conn => conn.Type == ConnectionType.Data))
{
bool srcComponent;
bool dstComponent;
string dstSmvVar = Smv.ConvertConnectionVariableName(connection.Destination, Smv.ModuleParameters.Variable, out dstComponent);
string srcSmvVar = Smv.ConvertConnectionVariableName(connection.Source, Smv.ModuleParameters.Variable, out srcComponent);
string srcString = "";
/*if (srcComponent && dstComponent)
* {
* //srcString = "\t" + srcSmvVar + " : " + Smv.True + ";\n"; //TODO: make direct connections without double-buffering
* var srcVar = _findVariable(connection.Source, allVariables, instances);
*
* if (srcVar.ArraySize == 0)
* dataConnections += String.Format(Smv.NextVarAssignment + "\n", dstSmvVar, srcSmvVar);
* else
* {
* for (int i = 0; i < srcVar.ArraySize; i++)
* {
* dataConnections += String.Format(Smv.NextVarAssignment + "\n", dstSmvVar + Smv.ArrayIndex(i), srcSmvVar + Smv.ArrayIndex(i));
* }
* }
* }
* else */
if (!srcComponent && dstComponent)
{
var dstVar = _findVariable(connection.Destination, allVariables, instances);
if (dstVar.ArraySize == 0)
{
srcString = FbSmvCommon.VarSamplingRule(connection.Source, withConnections, false);
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString);
}
else
{
for (int i = 0; i < dstVar.ArraySize; i++)
{
srcString = FbSmvCommon.VarSamplingRule(connection.Source, withConnections, false, i);
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar + Smv.ArrayIndex(i), srcString);
}
}
}
else if (srcComponent && !dstComponent)
{
IEnumerable <string> samplingEvents = _getSamplingEventNamesForVariable(connection.Destination, withConnections);
MultiMap <string> eventConnectionsMap = _getEventConnectionsMap(internalBuffers);
string eventSeed = "";
foreach (string ev in samplingEvents)
{
string src = "";
foreach (string parentEvent in eventConnectionsMap[ev])
{
bool dontCare;
src += Smv.ConvertConnectionVariableName(parentEvent, Smv.ModuleParameters.Event, out dontCare) + Smv.Or;
}
eventSeed += String.Format("({0}){1}", src.TrimEnd(Smv.OrTrimChars), Smv.Or);
}
var srcVar = _findVariable(connection.Source, allVariables, instances);
if (srcVar.ArraySize == 0)
{
srcString = String.Format("\t{0} : {1};\n", eventSeed.TrimEnd(Smv.OrTrimChars), srcSmvVar);
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString);
}
else
{
for (int i = 0; i < srcVar.ArraySize; i++)
{
srcString = String.Format("\t{0} : {1};\n", eventSeed.TrimEnd(Smv.OrTrimChars), srcSmvVar + Smv.ArrayIndex(i));
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar + Smv.ArrayIndex(i), srcString);
}
}
}
}
return(dataConnections);
}
