GenericBlockCreation.cs

using System;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using MAC_use_cases.TiaImports;
using Siemens.Automation.ModularApplicationCreator.Tia.Helper;
using Siemens.Automation.ModularApplicationCreator.Tia.Helper.Create_XML_Block;
using Siemens.Automation.ModularApplicationCreator.Tia.Helper.Create_XML_Block.XmlBlocks.BlockFrames;
using Siemens.Automation.ModularApplicationCreator.Tia.Openness;
using Siemens.Automation.ModularApplicationCreator.Tia.Openness.SoftwareUnit;
using Siemens.Automation.ModularApplicationCreator.Tia.TiaAttributeFuncs;
using ProgrammingLanguage =
    Siemens.Automation.ModularApplicationCreator.Tia.Helper.Create_XML_Block.ProgrammingLanguage;
 
namespace MAC_use_cases.Model.UseCases;

public class GenericBlockCreation
{
    public static string ParameterName = "myParameterName";

 
    // TODO expand for sw-units
    public static void CreateFunctionBlock(string blockName, string instanceDbName,
        ProgrammingLanguage programmingLanguage,
        PlcDevice plcDevice)
    {
        // Input validation
        if (string.IsNullOrEmpty(blockName))
        {
            throw new ArgumentNullException(nameof(blockName));
        }
 
        if (string.IsNullOrEmpty(instanceDbName))
        {
            throw new ArgumentNullException(nameof(instanceDbName));
        }
 
        if (plcDevice == null)
        {
            throw new ArgumentNullException(nameof(plcDevice));
        }
 
        if (programmingLanguage != ProgrammingLanguage.LAD && programmingLanguage != ProgrammingLanguage.FBD &&
            programmingLanguage != ProgrammingLanguage.SCL)
        {
            throw new ArgumentException(nameof(programmingLanguage));
        }
 
        // Create block call with default values
        var fbCall = new BlockCall(instanceDbName, plcDevice) { ["Input1"] = "1", ["Input2"] = "0" };
 
        // Create and configure network
        var fbNetwork = new BlockNetwork { NetworkTitles = { [TypeMapper.BaseCulture.Name] = "myFB Network Title" } };
        fbNetwork.Blocks.Add(fbCall);
 
        // Create and Configure FB properties
        var fb = new XmlFB(blockName);
        fb.Networks.Add(fbNetwork);
        fb.BlockAttributes.ProgrammingLanguage = programmingLanguage;
        fb.BlockComments[TypeMapper.BaseCulture.Name] = "myFB Block Comment";
        fb.BlockTitles[TypeMapper.BaseCulture.Name] = "myFB Block Title";
 
        // Generate the block in appropriate format
        if (programmingLanguage == ProgrammingLanguage.SCL)
        {
            fb.GenerateSclBlock(plcDevice);
        }
        else
        {
            fb.GenerateXmlBlock(plcDevice);
        }
    }

    public static void CreateFailSafeFunctionBlock(string blockName, string instanceDbName,
        ProgrammingLanguage programmingLanguage,
        PlcDevice plcDevice)
    {
        // Input validation
        if (string.IsNullOrEmpty(blockName))
        {
            throw new ArgumentNullException(nameof(blockName));
        }
 
        if (string.IsNullOrEmpty(instanceDbName))
        {
            throw new ArgumentNullException(nameof(instanceDbName));
        }
 
        if (plcDevice == null)
        {
            throw new ArgumentNullException(nameof(plcDevice));
        }
 
        if (programmingLanguage != ProgrammingLanguage.F_LAD && programmingLanguage != ProgrammingLanguage.F_FBD)
        {
            throw new ArgumentException(nameof(programmingLanguage));
        }
 
        // Create block call with default values
        var fbCall = new BlockCall(instanceDbName, plcDevice) { ["Input1"] = "1", ["Input2"] = "0" };
 
        // Create and configure network
        var fbNetwork = new BlockNetwork { NetworkTitles = { [TypeMapper.BaseCulture.Name] = "myFB Network Title" } };
        fbNetwork.Blocks.Add(fbCall);
 
        //Create and configure FB properties
        var failSafeBlock = new XmlFailSafeFB(blockName);
        failSafeBlock.Networks.Add(fbNetwork);
        failSafeBlock.BlockAttributes.ProgrammingLanguage = programmingLanguage;
        failSafeBlock.BlockComments[TypeMapper.BaseCulture.Name] = "myFB Block Comment";
        failSafeBlock.BlockTitles[TypeMapper.BaseCulture.Name] = "myFB Block Title";
 
        // Generate the block in appropriate format
        failSafeBlock.GenerateXmlBlock(plcDevice, programmingLanguage);
    }
 

    public static XmlGlobalDB GenerateGlobalDataBlock(string dbName, PlcDevice plcDevice, MAC_use_casesEM module)
    {
        var dataBlock = new XmlGlobalDB(dbName);
        var itf = dataBlock.Interface[InterfaceSections.Static];
 
        //Create new parameters. The custom parameter means you are using your own user defined data type.
        var standardParam = new InterfaceParameter(ParameterName, "Int");
        var customParam1 = new InterfaceParameter("var_struct", "Struct");
        customParam1.SubParameter.Add(new InterfaceParameter("Var1", "Bool"));
        customParam1.SubParameter.Add(new InterfaceParameter("Var2", "Int"));
        var customParam2 = new InterfaceParameter("datatyp_from_lib", "\"" + "myDataType" + "\"");
 
        //Add your parameters 
        itf.Add(standardParam);
        itf.Add(customParam1);
        itf.Add(customParam2);
 
        dataBlock.GenerateXmlBlock(plcDevice);
        return dataBlock;
    }

    public static void CreateFunctionBlockInSoftwareUnit(ISoftwareUnitBase softwareUnitBase, string fbName,
        ProgrammingLanguage programmingLanguage, PlcDevice plcDevice)
    {
        var fb = new XmlFB(fbName);
 
        fb.Interface[InterfaceSections.Input].Add(new InterfaceParameter("Input_1", "Bool")
        {
            Remanence = RemanenceSettings.IgnoreRemanence
        });
        fb.Interface[InterfaceSections.Input].Add(new InterfaceParameter("Input_2", "Bool")
        {
            Remanence = RemanenceSettings.IgnoreRemanence
        });
        fb.Interface[InterfaceSections.Output].Add(new InterfaceParameter("Output", "Bool")
        {
            Remanence = RemanenceSettings.IgnoreRemanence
        });
 
        //here an example how to create a multi instance call in the function block
        if (programmingLanguage == ProgrammingLanguage.SCL)
        {
            fb.GenerateSclBlock(softwareUnitBase);
        }
        else
        {
            fb.GenerateXmlBlock(softwareUnitBase, programmingLanguage);
        }
        var block = softwareUnitBase.Blocks.ToList().FirstOrDefault(b => b.Value.Name == fbName);
        block.Value.Namespace = "Namespace_Block";
    }

    private static void GenerateBlock(string code, PlcDevice targetDevice, ITarget targetContainer = null,
        bool isScl = true)
    {
        //Get the right file extension depending on the block language
        var extension = ".scl";
        if (!isScl)
        {
            extension = ".xml";
        }
 
        //Create a temporary file
        var filePath = Path.ChangeExtension(Path.GetTempFileName(), extension);
 
        //Write the code to this file
        File.WriteAllText(filePath, code);
 
        //Create the block on the plc using the file
        var block = OpennessFuncs.ImportBlockToPlc(filePath, targetDevice, targetContainer);
 
        //Delete the file
        File.Delete(filePath);
    }

    public static void SetDefaultValue(string dbName, string parameterName, TIATYPE dataType, string value,
        MAC_use_casesEM parent)
    {
        var myParameterNameAttribute = TiaAttributeProvider.CreateAttribute(dataType, SOURCETYPE.BLOCKVAR,
            dbName, parameterName, parent);
        myParameterNameAttribute.Value = value;
    }

    public static void GenerateMultiInstanceFB(PlcDevice plcDevice, string languageSettings, MAC_use_casesEM module)
    {
        var myFb = new XmlFB("MyFunctionBlock_MultiInstance")
        {
            BlockAttributes = { ProgrammingLanguage = ProgrammingLanguage.LAD }
        };
 
        var multiInstanceDataBlockName = myFb.Name + "_Instance";
        var myMultiInstanceFbCall =
            new MultiInstanceCall(multiInstanceDataBlockName, module.ResourceManagement.MyFunctionBlock.Name, plcDevice)
            {
                ["Input1"] = "1", // inputVariable1
                ["Input2"] = "0" // inputVariable1
            };
 
        //manipulate interface
        var interfaceParameters = myFb.Interface[InterfaceSections.Static];
 
        //Create new parameters. The custom parameter means you are using your own user defined data type.
        var customParam =
            new InterfaceParameter(multiInstanceDataBlockName,
                module.ResourceManagement.MyFunctionBlock.Name) { Remanence = RemanenceSettings.IgnoreRemanence };
 
        //Add your parameters 
        interfaceParameters.Add(customParam);
 
        var networkMultiInstance = new BlockNetwork();
        networkMultiInstance.Blocks.Add(myMultiInstanceFbCall);
        networkMultiInstance.GenerationLabel =
            new GenerationLabel(module.Name, "Generated by MAC", module.ModuleID.ToString());
        myFb.Networks.Add(networkMultiInstance);
        AddCodeBlockToOB(myFb, module.ResourceManagement, languageSettings, plcDevice);
    }

    public static void GenerateOB_Main(string instanceDbName, MAC_use_casesEM module, string languageSettings,
        PlcDevice plcDevice)
    {
        var mainOb = new XmlOB("Main");
        mainOb.BlockAttributes.ProgrammingLanguage = ProgrammingLanguage.LAD;
        ((OB_BlockAttributes)mainOb.BlockAttributes).BlockSecondaryType = "ProgramCycle";
 
        var itf = mainOb.Interface[InterfaceSections.Temp];
        var temp = new InterfaceParameter("Temp", "Bool");
        var tempInt = new InterfaceParameter("TempInt", "Int");
        itf.Add(temp);
        itf.Add(tempInt);
 
        //create block call of instance DB 
        var myFBCall = new BlockCall(instanceDbName, plcDevice)
        {
            ["Input1"] = "#Temp", // inputVariable1
            ["Input2"] = "0" // inputVariable1
            //["Input2"] = "inputVariable1", 
 
            //["Output1"] = "outputVariable1", 
        };
        var blockNetwork = new BlockNetwork();
        blockNetwork.Blocks.Add(myFBCall);
        blockNetwork.GenerationLabel =
            new GenerationLabel(module.Name, "Generated by MAC", module.ModuleID.ToString());
        mainOb.Networks.Add(blockNetwork);

        var content = "\"MyDataBlock_Global\".myParameterName := 100;\n";
        content += "IF #Temp THEN\n";
        content += "#TempInt := 5;\n";
        content += "ELSE\n";
        content += "TempInt := 1;\n";
        content += "END_IF;\n\n";
        var sclContent = content;
        var sclcode_network = ParseSingleSCLCall(sclContent, plcDevice, mainOb);
        sclcode_network.GenerationLabel =
            new GenerationLabel(module.Name, "Virtual_Master_scl_code", module.ModuleID.ToString());
        mainOb.Networks.Add(sclcode_network);
 
        AddCodeBlockToOB(mainOb, module.ResourceManagement, languageSettings, plcDevice);
    }

    public static void AddCodeBlockToOB(XmlLogicalBlock codeBlock, ResourceManagement resourceManagement,
        string languageSettings, PlcDevice plcDevice)
    {
        var existingOB = OpennessFuncs.TryGetOBFromPlcDevice(plcDevice, codeBlock.Name);
        //Create new OB in SCL with calling code
        if (existingOB == null)
        {
            if (codeBlock.BlockAttributes.ProgrammingLanguage == ProgrammingLanguage.SCL)
            {
                codeBlock.GenerateSclBlock(plcDevice);
            }
            else //insert networks to KOP/FUP
            {
                codeBlock.GenerateXmlBlock(plcDevice, null, languageSettings);
            }
        }
        else
            //Insert Code to existing OB
        {
            var blockAsDoc =
                OpennessFuncs.ExportBlockAsXml(existingOB.Name, plcDevice, OpennessFuncs.CachingOptions.DISABLED);
            var parser = new Parser();
            var xmlOB = parser.ParseXml(blockAsDoc);
            xmlOB.MergeBlock(codeBlock);
            //add SCL-Code
            if (xmlOB.BlockAttributes.ProgrammingLanguage == ProgrammingLanguage.SCL)
            {
                xmlOB.GenerateSclBlock(plcDevice);
            }
            else //insert networks to KOP/FUP
            {
                xmlOB.GenerateXmlBlock(plcDevice, null, languageSettings);
            }
        }
    }

    public static void GenerateOBWithMultipleCalls(string name, int numberOfCalls, string languageSettings,
        PlcDevice plcDevice, MAC_use_casesEM module)
    {
        var myOb = new XmlOB(name);
        myOb.BlockAttributes.BlockAutoNumber = false;
        myOb.BlockAttributes.BlockNumber = 555.ToString();
 
        for (var i = 1; i <= numberOfCalls; i++)
        {
            var blockName = $"{nameof(module.ResourceManagement.MyFunctionBlock)}DB" + i;
            IntegrateLibraries.CreateInstanceDataBlock(module, module.ResourceManagement.MyFunctionBlock,
                blockName, module.ResourceManagement.ModuleBlocksRootGroup);
            var myOBCall = new BlockCall(blockName, plcDevice)
            {
                ["Input1"] = "1", // inputVariable1
                ["Input2"] = "0" // inputVariable1
            };
 
            var myObBlockNetwork = new BlockNetwork();
            myObBlockNetwork.Blocks.Add(myOBCall);
            myObBlockNetwork.GenerationLabel = new GenerationLabel(blockName,
                "Generated by MAC. Blockname: \"" + blockName + "\"", module.ModuleID.ToString());
            myOb.Networks.Add(myObBlockNetwork);
        }
 
        AddCodeBlockToOB(myOb, module.ResourceManagement, languageSettings, plcDevice);
    }
 
    private static INetwork ParseSingleSCLCall(string sclCall, PlcDevice plc, XmlBlock xmlBlock)
    {
        var parsed = new Parser().ParseSclSnippet(sclCall, xmlBlock, plc, GroupBlockCalls.NOGROUPING)
            .FirstOrDefault();
        if (parsed is BlockNetwork blockNetwork)
        {
            return blockNetwork;
        }
 
        if (parsed is FixNetwork fixNetwork)
        {
            return fixNetwork;
        }
 
        return null;
    }
}