private ITcSmTreeItem createItf(ItfInfo itfInfo, ITcSmTreeItem parent, IWorker worker, XmlDocument doc)
{
XmlNode itfNode = doc.SelectSingleNode("TcPlcObject/Itf");
string itfName = itfNode.Attributes["Name"].Value;
worker.ProgressStatus = string.Format("Creating Interface '{0}' ...", itfName);
ITcSmTreeItem item = null;
XmlElement node = (XmlElement)doc.SelectSingleNode("TcPlcObject/Itf/Declaration");
string declString = node.InnerText;
if (!TryLookupChild(parent, itfName, out item))
{
item = parent.CreateChild(itfName, TreeItemType.PlcInterface.AsInt32(), "", declString);
}
//Debug.Fail("");
ITcXmlDocument xmlDoc = (ITcXmlDocument)item;
xmlDoc.DocumentXml = doc.OuterXml;
ITcPlcDeclaration decl = (ITcPlcDeclaration)item;
//decl.DeclarationText = node.InnerText;
return(item);
}
private ITcSmTreeItem createPlcFolder(ITcSmTreeItem parent, string folderName, string before, IWorker worker)
{
worker.ProgressStatus = string.Format("Creating Folder '{0}' ...", folderName);
ITcSmTreeItem item = parent.CreateChild(folderName, TreeItemType.PlcFolder.AsInt32(), before, null);
return(item);
}
private void createFBCalls(string[] boxName)
{
//acuire project instance of MAIN Pou
//then tell TwinCAT to create 3 new Actions for MAIN
ITcSmTreeItem mainPOU = sysMan.LookupTreeItem("TIPC^Untitled1^Untitled1 Project^POUs^MAIN");
ITcSmTreeItem fbBlockAct = mainPOU.CreateChild("A_Block", 608, "");
ITcSmTreeItem fbInitAct = mainPOU.CreateChild("A_Init", 608, "");
ITcPlcPou pouMain = (ITcPlcPou)mainPOU;
ITcPlcImplementation actBlock = (ITcPlcImplementation)fbBlockAct;
ITcPlcImplementation actInit = (ITcPlcImplementation)fbInitAct;
ITcPlcImplementation pouMainImpl = (ITcPlcImplementation)pouMain;
ITcPlcDeclaration pouMainDecl = (ITcPlcDeclaration)pouMain;
generateMainDecl(ref pouMainDecl, ref boxName);
generateMainImpl(ref pouMainImpl);
generateBlockAct(ref actBlock, ref boxName);
generateInitAct(ref actInit, ref boxName);
}
//<Not used>
public void addBaseSln(String slnBasePath) //For adding collab code automatically - requires better gitbash
{
string template = slnBasePath + @"\tc_project_app\tc_project_app.plcproj"; //path toproject template
ITcSmTreeItem plc = SystemManager.LookupTreeItem("TIPC");
try
{
ITcSmTreeItem newProject = plc.CreateChild("basePLC", 0, "", template);
}
catch
{
MessageBox.Show("Nope"); //Change the template so it detects version installed and knows where to look
}
}
public SolutionHandler(string filePath, string FileName)
{
this.BASEFOLDER = filePath;
this._solutionName = _tcProjectName = FileName;
this.adsClient = new TcAdsClient();
MessageFilter.Register();
/* -----------------------------------------------------------------
* Creates new solution based off of TwinCAT's XAE and PLC templates.
* -----------------------------------------------------------------*/
if (dte == null)
{
CreateNewProject();
}
pro = sol.Projects.Item(1);
sysMan = (ITcSysManager11)pro.Object;
//System.Threading.Thread.Sleep(5000);
ITcSmTreeItem plc = sysMan.LookupTreeItem("TIPC");
plc.CreateChild("Untitled1", 0, "", "Standard PLC Template");
//---Navigate to References node and cast to Library Manager interface
ITcSmTreeItem references = sysMan.LookupTreeItem("TIPC^Untitled1^Untitled1 Project^References");
ITcPlcLibraryManager libraryManager = (ITcPlcLibraryManager)this.RetrieveLibMan();
/* ------------------------------------------------------
* Check to see if library already exists, if it does it will delete before adding to avoid any exceptions.
* ------------------------------------------------------ */
foreach (ITcPlcLibRef libraryReference in libraryManager.References)
{
if (libraryReference is ITcPlcLibrary)
{
ITcPlcLibrary library = (ITcPlcLibrary)libraryReference;
if (library.Name == "MDR_Control")
{
DeleteLibrary(ref libraryManager);
}
}
}
/* ------------------------------------------------------
* Add our MDR library to the project References.
* ------------------------------------------------------ */
AddLibrary(ref libraryManager);
MessageFilter.Revoke();
}//Constructor()
private ITcSmTreeItem CreateBox(ITcSmTreeItem parent, BoxInfo boxInfo, IWorker worker)
{
worker.ProgressStatus = string.Format("Creating Box '{0}' ({1})...", boxInfo.Name, boxInfo.Type);
ITcSmTreeItem ret = parent.CreateChild(boxInfo.Name, (int)BoxType.EtherCAT_EXXXXX, "", boxInfo.Type);
if (boxInfo.ChildBoxes != null)
{
foreach (BoxInfo child in boxInfo.ChildBoxes)
{
ITcSmTreeItem tcChild = CreateBox(ret, child, worker);
}
}
return(ret);
}
protected void CreateMotion(IWorker worker)
{
if (worker.CancellationPending)
{
throw new Exception("Execution cancelled!");
}
OrderScriptContext context = (OrderScriptContext)_context;
ConfigurationInfo configurationInfo = context.Order.ConfigurationInfo;
ITcSmTreeItem ncConfig = systemManager.LookupTreeItem("TINC");
foreach (TaskInfo taskInfo in configurationInfo.MotionTasks)
{
ITcSmTreeItem task = null;
worker.ProgressStatus = string.Format("Creating Motion Task '{0}'", taskInfo.Name);
if (!TryLookupChild(ncConfig, taskInfo.Name, out task))
{
task = ncConfig.CreateChild(taskInfo.Name, 1);
}
ITcSmTreeItem axes = null;
TryLookupChild(task, "Axes", out axes);
if (axes == null)
{
TryLookupChild(task, "Achsen", out axes);
}
foreach (AxisInfo axisInfo in taskInfo.Axes)
{
if (worker.CancellationPending)
{
throw new Exception("Execution cancelled!");
}
ITcSmTreeItem axis = null;
worker.ProgressStatus = string.Format("Creating Axis '{0}'", axisInfo.Name);
if (!TryLookupChild(axes, axisInfo.Name, out axis))
{
axis = axes.CreateChild(axisInfo.Name, 1);
ConsumeTemplate(axis, axisInfo.TemplatePath);
}
}
}
}
private ITcSmTreeItem createPou(POUInfo pouInfo, ITcSmTreeItem parent, IWorker worker, XmlDocument doc)
{
XmlNode pouNode = doc.SelectSingleNode("TcPlcObject/POU");
string pouName = pouNode.Attributes["Name"].Value;
worker.ProgressStatus = string.Format("Creating POU '{0}' ...", pouName);
ITcSmTreeItem item = null;
if (!TryLookupChild(parent, pouName, out item))
{
item = parent.CreateChild(pouName, TreeItemType.PlcPouFunctionBlock.AsInt32(), "", null);
}
// some items need to be casted to a more special interface to gain access to all of their methods and properties, for example POUs which need
// to be casted to the interface ITcPlcPou to get access to their unique methods and properties.
ITcPlcPou pou = (ITcPlcPou)item;
pou.DocumentXml = doc.OuterXml; // get/set PLC code of a POU in XML Format
return(item);
}
}//LinkIoToPlc()
private void createDriveStruct()
{
//create strings for the beginning and end of the struct declaration
string structStart = "TYPE ST_EP7402:" + Environment.NewLine + "STRUCT" + Environment.NewLine;
string structEnd = "END_STRUCT" + Environment.NewLine + "END_TYPE" + Environment.NewLine;
//create the DUT and assign it to a container
ITcSmTreeItem DUT = sysMan.LookupTreeItem("TIPC^Untitled1^Untitled1 Project^DUTs");
ITcSmTreeItem driveStruct = DUT.CreateChild("ST_EP7402", 606, "");
ITcPlcDeclaration structDecl = (ITcPlcDeclaration)driveStruct;
string sdeclarationText;
//create a string for generating the member declaration of the struct.
string structMembers = @"stInputs AT %I* : EP7402_Inputs;" + Environment.NewLine +
"stOutputs AT %Q* : EP7402_Outputs;" + Environment.NewLine;
//combine the string into a single string to create the declaration text
sdeclarationText = structStart + structMembers + structEnd;
structDecl.DeclarationText = sdeclarationText;
}
private ITcSmTreeItem createDut(DataTypeInfo info, ITcSmTreeItem parent, IWorker worker, XmlDocument doc)
{
XmlNode dutNode = doc.SelectSingleNode("TcPlcObject/DUT");
string typeName = dutNode.Attributes["Name"].Value;
worker.ProgressStatus = string.Format("Creating Type '{0}' ...", typeName);
XmlNode declNode = dutNode.SelectSingleNode("Declaration");
string declaration = string.Empty;
declaration = declNode.InnerText;
ITcSmTreeItem dataTypeItem = parent.CreateChild(typeName, TreeItemType.PlcDutStruct.AsInt32(), "", declaration);
ITcPlcDeclaration decl = (ITcPlcDeclaration)dataTypeItem;
ITcXmlDocument tcDoc = (ITcXmlDocument)dataTypeItem;
string xml = tcDoc.DocumentXml;
return(dataTypeItem);
}
private ITcSmTreeItem createGvl(GvlInfo gvlInfo, ITcSmTreeItem parent, IWorker worker, XmlDocument doc)
{
XmlNode gvlNode = doc.SelectSingleNode("TcPlcObject/GVL");
string gvlName = gvlNode.Attributes["Name"].Value;
worker.ProgressStatus = string.Format("Creating GlobalVariable Sheet '{0}' ...", gvlName);
ITcSmTreeItem item = null;
if (!TryLookupChild(parent, gvlName, out item))
{
item = parent.CreateChild(gvlName, TreeItemType.PlcGvl.AsInt32());
}
ITcXmlDocument xmlDoc = (ITcXmlDocument)item;
ITcPlcDeclaration decl = (ITcPlcDeclaration)item;
XmlElement node = (XmlElement)doc.SelectSingleNode("TcPlcObject/GVL/Declaration");
decl.DeclarationText = node.InnerText;
return(item);
}
private void CreateModuleCode()
{
String eventManagerName;
//-----------------------------------------------------------------------------------------------------------------------
//---------------------------------Create module In-Out Structs --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
moduleConditionsToFire = dut.CreateChild(
module.getName + "conditionsToFire",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintModuleOutStruct,
new string[] { "@moduleName@" },
new string[] { module.getName }
)
);
//Structure that defines the Event-Triggers that will be used as inputs in the Eventmanager
moduleEventTriggers = dut.CreateChild(
module.getName + "EventTriggers",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintModuleInStruct,
new string[] { "@moduleName@" },
new string[] { module.getName }
)
);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Fill the ModulesGVL ----------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
modulesGvlImplementation = "\t" + module.getName + ": " + module.getName + ";" + "\n";
decl = (ITcPlcDeclaration)modules;
index = decl.DeclarationText.IndexOf(keyVarGlobal);
decl.DeclarationText =
decl.DeclarationText.Insert(
index + (keyVarGlobal.Length + 1),
modulesGvlImplementation
);
//-----------------------------------------------------------------------------------------------------------------------
//------------------------------------------------Create the FB_TargetModule---------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//604 TREEITEMTYPE_PLCPOUFB POU Function Block
ITcSmTreeItem targetModule = pou.CreateChild(module.getName, 604, "1");
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_TargetModule Methods --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
moduleEventManagerDeclaration = null;
eventNamesLists.Clear();
foreach (EventManager eventManager in module.content)
{
eventNamesLists.Add(eventManager.content.eventNames);
eventManagerNames.Add(eventManager.getName);
moduleEventManagerDeclaration += Assigner.ReplaceBlueprintValues(
"\t" + AssignedConfigFileData.blueprintModuleEventManagerDeclaration + "\n",
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
);
moduleEventManagerImplementation += Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintModuleEventManagerImplementation + "\n",
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
);
}
foreach (String[] eventNamesGroup in eventNamesLists)
{
eventManagerName = eventManagerNames.First();
eventManagerNames.RemoveAt(0);
foreach (String eventName in eventNamesGroup)
{
//Create EventMethods
currentMethod = targetModule.CreateChild(eventName + "Event", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventMethodDeclaration,
new string[] { "@eventName@" },
new string[] { eventName }
);
//Create SenderMethods
currentMethod = targetModule.CreateChild("fire" + Functions.UppercaseFirst(eventName) + "Event", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintSenderMethodDeclaration,
new string[] { "@eventName@" },
new string[] { eventName }
);
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintSenderMethodImplementation,
new string[] { "@eventName@", "@eventManagerName@" },
new string[] { eventName, eventManagerName }
);
outConditionsToFire += "\t" + eventName + "Event : BOOL;\n";
eventRaiserImplementation += Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventRaiserImplementation + "\n",
new string[] { "@eventName@" },
new string[] { eventName }
);
moduleTriggerEventDeclaration += Assigner.ReplaceBlueprintValues(
"\t" + AssignedConfigFileData.blueprintModuleTriggerEventsDeclaration + "\n",
new string[] { "@eventName@" },
new string[] { Functions.UppercaseFirst(eventName) }
);
}
}
//Fill the module structures with the relevant data
//--------------------------------------------------------------------------------
decl = (ITcPlcDeclaration)moduleEventTriggers;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
moduleTriggerEventDeclaration
);
decl = (ITcPlcDeclaration)moduleConditionsToFire;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
outConditionsToFire
);
//--------------------------------------------------------------------------------
//eventRaiser method
currentMethod = targetModule.CreateChild("eventRaiser", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintEventRaiserDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = eventRaiserImplementation;
//callComponents method
currentMethod = targetModule.CreateChild("callComponents", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintCallComponentsDeclaration;
//registerSequence method
currentMethod = targetModule.CreateChild("registerSequence", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintRegisterSequenceDeclarationText;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintRegisterSequenceImplementationText;
//runSequence method
currentMethod = targetModule.CreateChild("runSequence", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintRunSequenceDeclarationText;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintRunSequenceImplementationText;
/*
* currentMethod = targetModule.CreateChild("eventRaiser", 609, "", methodDescription);
*
* //M_EventRaiser
* decl = (ITcPlcDeclaration)currentMethod;
* decl.DeclarationText = AssignedConfigFileData.blueprintEventRaiserDeclaration;
*
* impl = (ITcPlcImplementation)currentMethod;
* impl.ImplementationText = eventRaiserImplementation;
*
* currentMethod = targetModule.CreateChild("callComponents", 609, "", methodDescription);
*
* //M_CallComponents
* decl = (ITcPlcDeclaration)currentMethod;
* decl.DeclarationText = AssignedConfigFileData.blueprintCallComponentsDeclaration;
*/
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Fill the declaration and implementation part of FB_TargetModule with code-------------------
//-----------------------------------------------------------------------------------------------------------------------
decl = (ITcPlcDeclaration)targetModule;
impl = (ITcPlcImplementation)targetModule;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.modulesDeclarations[targetIndex],
new string[] { "@eventManagers", "@moduleName@" },
new string[] { moduleEventManagerDeclaration, module.getName }
);
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.modulesImplementations[targetIndex],
new string[] { "@eventManagers" },
new string[] { moduleEventManagerImplementation }
);
}
private void CreateEventManagerCode()
{
//-----------------------------------------------------------------------------------------------------------------------
//------------------------------------------------Create the FB_EventManager---------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
foreach (EventManager eventManager in module.content)
{
ITcSmTreeItem fbEventManager = eventManagers.CreateChild(eventManager.getName + "EventManager", 604, "1");
String[] eventNameGroup = eventManager.content.eventNames;
outEventManagerEvents = null;
eventManagerEventsStrings = null;
eventDispatcherImplementation = null;
handlerOperations = null;
enumEventDeclaration = null;
triggersImplementation = null;
foreach (String eventName in eventNameGroup)
{
outEventManagerEvents += "\t" + eventName + "Event : BOOL;\n";
if (eventNameGroup.Last() == eventName)
{
eventManagerEventsStrings += "\t\t'" + eventName + "Event'\n";
}
else
{
eventManagerEventsStrings += "\t\t'" + eventName + "Event',\n";
}
eventDispatcherImplementation += Assigner.ReplaceBlueprintValues(
"\n" + AssignedConfigFileData.blueprintEventDispatcherImplementation,
new string[] { "@eventManagerName@", "@eventName@" },
new string[] { eventManager.getName, eventName }
);
handlerOperations += Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintHandlerOperation + "\n",
new string[] { "@eventManagerName@", "@eventName@", "@moduleName@" },
new string[] { eventManager.getName, eventName, module.getName }
);
enumEventDeclaration += "\t" + eventName + "Event,\n";
triggersImplementation += "\t" + eventName + "RTrigger : R_TRIG;" + "\n";
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_EventManager eventReceivers -------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//Implement receivers
currentReceiver = fbEventManager.CreateChild(eventName + "Receiver", 611, "", propertyDescription);
decl = (ITcPlcDeclaration)currentReceiver;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintReceiversDeclaration,
new string[] { "@eventName@" },
new string[] { eventName }
);
//Implement getters
currentReceiver = currentReceiver.CreateChild("", 613, "", "1");
impl = (ITcPlcImplementation)currentReceiver;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintReceiversGetterImplementation,
new string[] { "@eventManagerName@", "@eventName@" },
new string[] { eventManager.getName, eventName }
);
}
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Create the E_<X>Event Enumaration ---------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//605 TREEITEMTYPE_PLCDUTENUM DUT enum data type
dut.CreateChild(
eventManager.getName + "Event",
605, "",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEnumEventDeclaration,
new string[] { "@eventManagerName@", "@eventNames" },
new string[] { eventManager.getName, enumEventDeclaration }
)
);
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Create the EventManager-Structures ----------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
dut.CreateChild(
eventManager.getName + "EventRecord",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventRecordDeclaration,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
)
);
//Structure that defines the Event-Triggers that will be used as inputs in the Eventmanager
eventManagerEventTriggers = dut.CreateChild(
eventManager.getName + "EventTriggers",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerInStruct,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
)
);
decl = (ITcPlcDeclaration)eventManagerEventTriggers;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
triggersImplementation
);
eventManagerEventReceivers = dut.CreateChild(
eventManager.getName + "EventReceiver",
606,
"",
Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerOutStruct,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
)
);
decl = (ITcPlcDeclaration)eventManagerEventReceivers;
index = decl.DeclarationText.IndexOf(keyVarStruct);
decl.DeclarationText = decl.DeclarationText.Insert(
index + (keyVarStruct.Length + 1),
outEventManagerEvents
);
//-----------------------------------------------------------------------------------------------------------------------
//-------------------------- Fill the declaration and implementation part of FB_EventManager with code-------------------
//-----------------------------------------------------------------------------------------------------------------------
decl = (ITcPlcDeclaration)fbEventManager;
impl = (ITcPlcImplementation)fbEventManager;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerDeclaration,
new string[] { "@eventManagerName@", "@eventStrings", "@moduleName@" },
new string[] { eventManager.getName, eventManagerEventsStrings, module.getName }
);
impl.ImplementationText = AssignedConfigFileData.blueprintEventManagerImplementation;
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_EventManager Methods --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
//M_CheckForRaceCondition
currentMethod = fbEventManager.CreateChild("checkForRaceCondition", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintRaceConditionDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintRaceConditionImplementation,
new string[] { "@eventManagerName@" },
new string[] { eventManager.getName }
);
//M_EventDispatcher
currentMethod = fbEventManager.CreateChild("eventDispatcher", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintEventDispatcherDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = eventDispatcherImplementation;
//M_ExecuteHandler
currentMethod = fbEventManager.CreateChild("executeHandler", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintExecuteHandlerDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintExecuteHandlerImplementation,
new string[] { "@handlerOperations" },
new string[] { handlerOperations }
);
//M_UpdateEventHistory
currentMethod = fbEventManager.CreateChild("updateEventHistory", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintUpdateEventHistoryDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintUpdateEventHistoryImplementation;
//M_UpdateEventRecord
currentMethod = fbEventManager.CreateChild("updateEventRecord", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintUpdateEventRecordDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintUpdateEventRecordImplementation,
new string[] { "@unequal" },
new string[] { "<>" }
);
//FB_Init
currentMethod = fbEventManager.CreateChild("FB_init", 609, "", methodDescription);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerFBInitDeclarationText,
new string[] { "@moduleName@" },
new string[] { module.getName }
);
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.blueprintEventManagerFBInitImplementationText,
new string[] { "@moduleName@" },
new string[] { module.getName }
);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------- Create the FB_EventManager disable signal -------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
disableSignal =
fbEventManager.
CreateChild("disableEventManagerSignal", 611, "", propertyDescription);
decl = (ITcPlcDeclaration)disableSignal;
decl.DeclarationText = AssignedConfigFileData.blueprintDisableEventManagerSignalDeclaration;
//Implement getter
currentSignal = disableSignal.CreateChild("", 613, "", "1");
impl = (ITcPlcImplementation)currentSignal;
impl.ImplementationText = AssignedConfigFileData.blueprintDisableEventManagerSignalGetterImplementation;
//Implement setter
currentSignal = disableSignal.CreateChild("", 614, "", "1");
impl = (ITcPlcImplementation)currentSignal;
impl.ImplementationText = AssignedConfigFileData.blueprintDisableEventManagerSignalSetterImplementation;
Console.WriteLine("Code for " + eventManager.getName + "EventManager" + " created.");
}
}
public void ScanDevicesAndBoxes(DataTable dt)
{
int config;
if ((config = checkForRunMode()) == 1)
{
ITcSmTreeItem ioDevicesItem = sysMan.LookupTreeItem("TIID"); // Get The IO Devices Node
// Scan Devices (Be sure that the target system is in Config mode!)
string scannedXml = ioDevicesItem.ProduceXml(false); // Produce Xml implicitly starts the ScanDevices on this node.
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(scannedXml); // Loads the Xml data into an XML Document
XmlNodeList xmlDeviceList = xmlDoc.SelectNodes("TreeItem/DeviceGrpDef/FoundDevices/Device");
List <ITcSmTreeItem> devices = new List <ITcSmTreeItem>();
//local variables for our spreadsheet writing statements
int deviceCount = 0;
int i = 2;
// Add all found devices to configuration
foreach (XmlNode node in xmlDeviceList)
{
// Add a selection or subrange of devices
int itemSubType = int.Parse(node.SelectSingleNode("ItemSubType").InnerText);
string typeName = node.SelectSingleNode("ItemSubTypeName").InnerText;
XmlNode xmlAddress = node.SelectSingleNode("AddressInfo");
ITcSmTreeItem device = ioDevicesItem.CreateChild(string.Format("Device_{0}", ++deviceCount), itemSubType, string.Empty, null);
string xml = string.Format("<TreeItem><DeviceDef>{0}</DeviceDef></TreeItem>", xmlAddress.OuterXml);
device.ConsumeXml(xml); // Consume Xml Parameters (here the Address of the Device)
devices.Add(device);
}
// Scan all added devices for attached boxes
foreach (ITcSmTreeItem device in devices)
{
string xml = "<TreeItem><DeviceDef><ScanBoxes>1</ScanBoxes></DeviceDef></TreeItem>"; // Using the "ScanBoxes XML-Method"
try
{
device.ConsumeXml(xml); // Consume starts the ScanBoxes and inserts every found box/terminal into the configuration
}
catch (Exception ex)
{
Console.WriteLine("Warning: {0}", ex.Message);
}
int j = 0;
foreach (ITcSmTreeItem Box in device)
{
if (Box.ItemSubTypeName.Contains("EP7402-0057"))
{
Box.Name = dt.Rows[j].ItemArray[0].ToString() + j.ToString();
this.EditParams(Box, dt.Rows[j].ItemArray[2].ToString());
j++;
LinkIoToPlc(Box);
}
} //for each Box
} //end of foreach loops
}
} //ScanDevicesandBoxes()
public void PLCdeclarations(DataTable dt)
{
string mainVar = @"VAR_GLOBAL" + Environment.NewLine;
string endMain = Environment.NewLine + @"
END_VAR";
string constDeclStart = @"VAR_GLOBAL CONSTANT" + Environment.NewLine;
string constDeclEnd = Environment.NewLine + @"
END_VAR";
createDriveStruct();
System.Threading.Thread.Sleep(3000);
//Add function blocks to MAIN declaration
ITcSmTreeItem main = sysMan.LookupTreeItem("TIPC^Untitled1^Untitled1 Project^GVLs");
ITcSmTreeItem GVL = main.CreateChild("MDR_Control_FBs", 615, "", 0);
ITcSmTreeItem StructGVL = main.CreateChild("EP7402_List", 615, "", 0);
//Cast to specific interface for declaration and implementation area
ITcPlcDeclaration mainDecl = (ITcPlcDeclaration)GVL;
ITcPlcDeclaration structDecl = (ITcPlcDeclaration)StructGVL;
//Get current declaration and implementation area content
string strMainDecl = mainDecl.DeclarationText;
string strStructDecl = structDecl.DeclarationText;
//string strMainImpl = mainImpl.ImplementationText;
_nDriveCount = dt.Rows.Count;
string[] boxName = new string[_nDriveCount];
int j = 0;
int i = 0;
string structCount = string.Format(" nDriveCount : UINT := {0};", _nDriveCount);
for (i = 0; i < _nDriveCount - 1; i++)
{
boxName[i] = dt.Rows[j].ItemArray[0].ToString() + j.ToString();
//Console.WriteLine(boxName[i]);
j++;
}
declarations = string.Join(": FB_MDR_Control;" + Environment.NewLine, boxName);
mainDecl.DeclarationText = mainVar + declarations + endMain;
for (i = 0; i < _nDriveCount - 1; i++)
{
boxName[i] = boxName[i].Insert(0, "st");
}
declarations = string.Join(": ST_EP7402;" + Environment.NewLine, boxName);
structDecl.DeclarationText = mainVar + declarations + endMain + Environment.NewLine + constDeclStart + structCount + constDeclEnd;
createFBCalls(boxName);
System.Threading.Thread.Sleep(2000);
var settings = dte.GetObject("TcAutomationSettings");
settings.SilentMode = true;
dte.Solution.SolutionBuild.Build(true); // compile the plc project
settings.SilentMode = false;
}
static void Main(string[] args)
{
//-----------------------------------------------------------------------------------------------------------------------
// Retrieve all relevant data from config file
//-----------------------------------------------------------------------------------------------------------------------
ConfigFileReader configFileReader = new ConfigFileReader();
Assigner assigner = new Assigner();
MessageFilter.Register();
//-----------------------------------------------------------------------------------------------------------------------
// Attach to existing Dte
//-----------------------------------------------------------------------------------------------------------------------
AssignedConfigFileData.pathToSolution = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToSolution,
new string[] { "@NameOfProject@" },
new string[] { AssignedConfigFileData.nameOfProject }
);
Console.WriteLine("pathToSolution: {0}", AssignedConfigFileData.pathToSolution);
AssignedConfigFileData.pathToPOUsFolder = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToPOUsFolder,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToPOUsFolder: {0}", AssignedConfigFileData.pathToPOUsFolder);
AssignedConfigFileData.pathToDUTsFolder = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToDUTsFolder,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToDUTsFolder: {0}", AssignedConfigFileData.pathToDUTsFolder);
AssignedConfigFileData.pathToGVLsFolder = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToGVLsFolder,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToGVLsFolder: {0}", AssignedConfigFileData.pathToGVLsFolder);
AssignedConfigFileData.pathToMAIN = Assigner.ReplaceBlueprintValues(
AssignedConfigFileData.pathToMAIN,
new string[] { "@NameOfPLCProject@" },
new string[] { AssignedConfigFileData.nameOfPlcProject }
);
Console.WriteLine("pathToMAIN: {0}", AssignedConfigFileData.pathToMAIN);
List <Project> projectList = new List <Project>();
Project plcProj = null;
bool projectFound = false;
ITcPlcDeclaration decl = (ITcPlcDeclaration)null;
ITcPlcImplementation impl = (ITcPlcImplementation)null;
ITcSmTreeItem currentMethod = null;
ITcSmTreeItem pou = null;
ITcSmTreeItem dut = null;
ITcSmTreeItem gvl = null;
ITcSmTreeItem main = null;
ITcSmTreeItem modules = null;
ITcSmTreeItem constants = null;
ITcSmTreeItem system = null;
ITcSmTreeItem targetModule = null;
ITcSmTreeItem triggers = null;
ITcSmTreeItem eventManagers = null;
ITcSmTreeItem interfaces = null;
ITcSmTreeItem i_sequence = null;
ITcSysManager sysManager = null;
EnvDTE.DTE dte =
DteAttacher.attachToExistingDte(
AssignedConfigFileData.pathToSolution,
AssignedConfigFileData.visualStudioVersion,
AssignedConfigFileData.nameOfProject
);
dynamic solution = dte.Solution;
Console.WriteLine("Full solution name:");
Console.WriteLine(solution.FullName);
Projects prjs = solution.projects;
Console.WriteLine("Projects in solution: {0}", prjs.Count);
for (int i = 1; i <= prjs.Count; i++)
{
projectList.Add(prjs.Item(i));
Console.WriteLine("Project found: {0}", prjs.Item(i).Name);
Console.WriteLine("Searching for project: {0}", AssignedConfigFileData.nameOfProject);
if (prjs.Item(i).Name.Equals(AssignedConfigFileData.nameOfProject))
{
plcProj = prjs.Item(i);
projectFound = true;
}
}
//-----------------------------------------------------------------------------------------------------------------------
// Perform checks
//-----------------------------------------------------------------------------------------------------------------------
Console.WriteLine("Performing checks:");
if (projectFound)
{
Console.WriteLine("Project found.");
sysManager = plcProj.Object;
}
else
{
Console.WriteLine("Project not found. Exiting on Enter.");
Console.Read();
return;
}
//Is POUs item available?
Functions.SearchForItem(AssignedConfigFileData.pathToPOUsFolder, ref sysManager, ref pou);
//Is DUTs item available?
Functions.SearchForItem(AssignedConfigFileData.pathToDUTsFolder, ref sysManager, ref dut);
//Is GVLs item available?
Functions.SearchForItem(AssignedConfigFileData.pathToGVLsFolder, ref sysManager, ref gvl);
//Is Main item available?
Functions.SearchForItem(AssignedConfigFileData.pathToMAIN, ref sysManager, ref main);
if (AssignedConfigFileData.activity.Equals("SpecificEventsModuleCreator"))
{
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- MAIN implementation -----------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
impl = (ITcPlcImplementation)main;
impl.ImplementationText = AssignedConfigFileData.blueprintMainImplementation;
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create methods for MAIN -------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
currentMethod = main.CreateChild("systemTime", 609, "");
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintMainSystemTimeDeclaration;
impl = (ITcPlcImplementation)currentMethod;
impl.ImplementationText = AssignedConfigFileData.blueprintMainSystemTimeImplementation;
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the ModulesGVL --------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
modules = gvl.CreateChild("Modules", 615, "", AssignedConfigFileData.blueprintModulesGvlDeclaration);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the ConstantsGVL ------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
constants = gvl.CreateChild("Constants", 615, "", AssignedConfigFileData.blueprintConstantsGvlDeclaration);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the SystemGVL ----------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
system = gvl.CreateChild("System", 615, "", AssignedConfigFileData.blueprintSystemGvlDeclaration);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the EventManagers folder -----------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
eventManagers = pou.CreateChild("EventManagers", 601, "", "1");
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the Interfaces folder --------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
interfaces = pou.CreateChild("Interfaces", 601, "", "1");
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the I_Sequence interface -----------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
i_sequence = interfaces.CreateChild("I_Sequence", 618);
//-----------------------------------------------------------------------------------------------------------------------
//--------------------------------- Create the sequence interface method ------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------
currentMethod = i_sequence.CreateChild("sequence", 610);
decl = (ITcPlcDeclaration)currentMethod;
decl.DeclarationText = AssignedConfigFileData.blueprintInterfaceSequenceMethodDeclaration;
}
else
{
//Is the Module GVL present?
Functions.SearchForSubItem("Modules", ref gvl, ref modules);
//Is the Triggers GVL present?
//Functions.SearchForSubItem("Triggers", ref gvl, ref triggers);
//Is the Eventmanagers folder present?
Functions.SearchForSubItem("EventManagers", ref pou, ref eventManagers);
}
//Is TargetModule present?
/*
* if (AssignedConfigFileData.activity.Equals("InjectNewEventManagerInTarget"))
* {
* Functions.SearchForItem(AssignedConfigFileData.pathToTargetModule, ref sysManager, ref targetModule);
* }
*/
//Is the Interfaces folder present?
//Functions.SearchForSubItem("Interfaces", ref pou, ref interfaces);
//-----------------------------------------------------------------------------------------------------------------------
// Start activity
//-----------------------------------------------------------------------------------------------------------------------
Console.WriteLine("Executing program.");
for (int i = 0; i < AssignedConfigFileData.modulesContainer.content.Length; i++)
{
if (AssignedConfigFileData.activity.Equals("GeneralEventsModuleCreator"))
{
new GeneralEventsModuleCreator(i, pou, dut, gvl, eventManagers, modules, triggers);
}
else if (AssignedConfigFileData.activity.Equals("SpecificEventsModuleCreator"))
{
new SpecificEventsModuleCreator(i, pou, dut, gvl, eventManagers, modules, triggers);
}
}
MessageFilter.Revoke();
Console.WriteLine("Finished!");
Console.Read();
}
/// <summary>
/// Durch die Hauptschnittstelle ITcSysManager können wir ein neue PLCProjekt generieren. Die Lookup-Methode ist implementiert.
/// </summary>
protected ITcSmTreeItem CreatePlcProject(IWorker worker)
{
if (worker.CancellationPending)
{
throw new Exception("Execution cancelled!");
}
OrderScriptContext context = (OrderScriptContext)_context;
ConfigurationInfo configurationInfo = context.Order.ConfigurationInfo;
string plcProjectName = configurationInfo.PlcProjectName;
ITcSmTreeItem plcConfig = systemManager.LookupTreeItem("TIPC"); //Navigation im PLC struktur im TC.
worker.ProgressStatus = string.Format("Creating empty PLC Project '{0}' ...", plcProjectName);
ITcSmTreeItem plcProjectRoot = plcConfig.CreateChild(plcProjectName, 0, "", vsXaePlcEmptyTemplateName); //diese Method ausführen, um ein neues PLCProjekt erstellen.
ITcPlcProject plcProjectRootIec = (ITcPlcProject)plcProjectRoot; //setting the properties of the PLC Project like boot option.
plcProjectRootIec.BootProjectAutostart = true;
plcProjectRootIec.GenerateBootProject(true);
ITcSmTreeItem plcProject = plcProjectRoot.LookupChild(plcProjectName + " Project"); // for example Schulung and Schulung Project. Now the ITcTreeItem pointer is pointing Schulung Project
foreach (PlcObjectInfo plcObjectInfo in context.Order.ConfigurationInfo.PlcObjects) //Creating all the components of the PLC Project
{
if (worker.CancellationPending)
{
throw new Exception("Execution cancelled!");
}
switch (plcObjectInfo.Type) // we can have library, placeholder, POU, ITf, GVL and so on...
{
case PlcObjectType.DataType: // PlcObjectType defined in ScriptInfo.
createWorksheet((WorksheetInfo)plcObjectInfo, plcProject, worker);
break;
case PlcObjectType.Library:
createLibrary((LibraryInfo)plcObjectInfo, plcProject, worker);
break;
case PlcObjectType.Placeholder:
createPlaceholder((PlaceholderInfo)plcObjectInfo, plcProject, worker);
break;
case PlcObjectType.POU: // first create folder and then create POU
createWorksheet((WorksheetInfo)plcObjectInfo, plcProject, worker);
break;
case PlcObjectType.Itf:
createWorksheet((WorksheetInfo)plcObjectInfo, plcProject, worker);
break;
case PlcObjectType.Gvl:
createWorksheet((WorksheetInfo)plcObjectInfo, plcProject, worker);
break;
default:
Debug.Fail("");
break;
}
}
ITcSmTreeItem realtimeTasks = systemManager.LookupTreeItem("TIRT"); //creating tasks
ITcSmTreeItem rtTask = realtimeTasks.CreateChild("PlcTask", TreeItemType.Task.AsInt32());
ITcSmTreeItem taskRef = null;
worker.ProgressStatus = "Linking PLC instance with task 'PlcTask' ...";
if (!TryLookupChild(plcProject, "PlcTask", out taskRef))
{
if (worker.CancellationPending)
{
throw new Exception("Execution cancelled!");
}
taskRef = plcProject.CreateChild("PlcTask", TreeItemType.PlcTask.AsInt32(), "", "MAIN");
}
//foreach (ITcSmTreeItem prog in taskRef)
//{
// string name = prog.Name;
//}
//ErrorItems errors;
//if (worker.CancellationPending)
// throw new Exception("Execution cancelled!");
//bool ok = CompileProject(worker, out errors);
//if (!ok)
// throw new ApplicationException(string.Format("Plc Project compile produced '{0}' errors. Please see Visual Studio Error Window for details.!", plcProject.Name));
return(plcProject);
}