Beispiel #1
0
 protected override void DoWork()
 {
     lock (portal)
     {
         try
         {
             PresetStoreSCL        scl         = new PresetStoreSCL(blockName, valueTypeName, null);
             PresetStoreEnabledSCL enabled_scl = new PresetStoreEnabledSCL(blockEnabledName, valueTypeName, enableTypeName, null);
             foreach (var tag in tags)
             {
                 if (!tag.noStore)
                 {
                     scl.AddStore(tag.tagPath);
                     enabled_scl.AddStore(tag.tagPath);
                 }
             }
             TIAutils.ImportPlcBlockXML(scl.Document, resultGroup);
             TIAutils.ImportPlcBlockXML(enabled_scl.Document, resultGroup);
         }
         catch (Exception ex)
         {
             LogMessage(MessageLog.Severity.Error, "Failed to create preset store SCL block:\n" + ex.Message);
             return;
         }
     }
 }
Beispiel #2
0
 protected override void DoWork()
 {
     lock (portal)
     {
         try
         {
             HMIConstantTable table = new HMIConstantTable(PRESET_CONSTANT_TABLE_NAME);
             foreach (KeyValuePair <string, ConstantLookup.Entry> entry in constants)
             {
                 if (entry.Key.StartsWith("PresetNumber"))
                 {
                     if (int.TryParse(entry.Value.value, out int value))
                     {
                         table.AddIntegerConstant(entry.Key, value);
                     }
                 }
             }
             TIAutils.ImportHMITagTableXML(table.Document, folder);
         }
         catch (Exception ex)
         {
             LogMessage(MessageLog.Severity.Error, "Failed to update preset constant table " + PRESET_CONSTANT_TABLE_NAME + "\n" + ex.Message);
             return;
         }
     }
 }
Beispiel #3
0
        protected override void DoWork()
        {
            lock (portal)
            {
                try
                {
                    TagTable table = folder.TagTables.Find(function);

                    if (table != null)
                    {
                        XmlDocument table_doc = TIAutils.ExportHMITagTableXML(table);
                        TagParser   parser    = new TagParser(portal);
                        parser.HandleTag += Parser_HandleTag;
                        parser.Parse(block, log, TagParser.Options.AllowNoComment | TagParser.Options.NoSubelement);

                        TIAutils.ImportHMITagTableXML(table_doc, folder);
                    }
                    else
                    {
                        LogMessage(MessageLog.Severity.Warning, "No tag table named " + function + " for tags from " + block.Name);
                    }
                }
                catch (Exception ex)
                {
                    LogMessage(MessageLog.Severity.Error, "Failed to update tag table from block:\n" + ex.Message);
                    return;
                }
            }
        }
Beispiel #4
0
        protected override void DoWork()
        {
            lock (portal)
            {
                try
                {
                    TagTable table = folder.TagTables.Find(tableName);

                    if (table != null)
                    {
                        XmlDocument   table_doc       = TIAutils.ExportHMITagTableXML(table);
                        HMITagTable   editor          = new HMITagTable(table_doc);
                        PathComponent enable_selected = new MemberComponent("EnableSelected", new STRUCT(), new MemberComponent(hmiDbName, new STRUCT()));
                        PathComponent preset_selected = new MemberComponent("PresetSelected", new STRUCT(), new MemberComponent(hmiDbName, new STRUCT()));

                        int index = 1;
                        foreach (var tag in tags)
                        {
                            editor.AddIndexedTag("PresetEnable_" + groupName + "_", index, tag.tagPath.PrependPath(enable_selected).ToString());
                            editor.AddIndexedTag("PresetValue_" + groupName + "_", index, tag.tagPath.PrependPath(preset_selected).ToString(), tag.tagPath.Type);

                            index++;
                        }

                        ARRAY name_array = new ARRAY();
                        name_array.MemberType = new STRING();
                        PathComponent preset_names = new MemberComponent("Names", name_array, new MemberComponent(dbName, new STRUCT()));
                        ARRAY         color_array  = new ARRAY();
                        color_array.MemberType = INT.Type;
                        PathComponent preset_colors = new MemberComponent("Colors", color_array, new MemberComponent(dbName, new STRUCT()));
                        for (int p = 1; p <= nPresets; p++)
                        {
                            PathComponent name = new IndexComponent(new int[1] {
                                p
                            }, new STRING(), preset_names);
                            editor.AddIndexedTag("PresetName_" + groupName + "_", p, name.ToString());
                            PathComponent color = new IndexComponent(new int[1] {
                                p
                            }, INT.Type, preset_colors);
                            editor.AddIndexedTag("PresetColor_" + groupName + "_", p, color.ToString());
                        }
                        TIAutils.ImportHMITagTableXML(table_doc, folder);
                    }
                    else
                    {
                        LogMessage(MessageLog.Severity.Warning, "No tag table named '" + tableName + "' was found, skipping.");
                    }
                }
                catch (Exception ex)
                {
                    LogMessage(MessageLog.Severity.Error, "Failed to update tag table:\n" + ex.Message);
                    return;
                }
            }
        }
        protected override void DoWork()
        {
            lock (portal)
            {
                try
                {
                    IntSet      idset = new IntSet();
                    XmlDocument doc   = new XmlDocument();
                    doc.LoadXml(Resources.InitialHMITextList);
                    XMLUtil.CollectID(doc.DocumentElement, idset);


                    XmlElement name_attr = doc.SelectSingleNode("/Document/Hmi.TextGraphicList.TextList/AttributeList/Name") as XmlElement;
                    name_attr.InnerText = list_name;

                    XmlElement entry_list = doc.SelectSingleNode("/Document/Hmi.TextGraphicList.TextList/ObjectList") as XmlElement;


                    {
                        MultilingualText text = new MultilingualText();
                        foreach (string culture in cultures)
                        {
                            text.AddText(culture, "?");
                        }
                        XmlElement entry = ListEntry(doc, 0, true, text);
                    }

                    List <int> keys = new List <int>(texts.Keys);
                    keys.Sort();
                    foreach (int k in keys)
                    {
                        XmlElement entry = ListEntry(doc, k, false, texts[k]);
                        entry_list.AppendChild(entry);
                        XMLUtil.ReplaceID(entry, idset);
                    }

                    TIAutils.ImportTextListXML(doc, text_lists);
                }
                catch (Exception ex)
                {
                    LogMessage(MessageLog.Severity.Error, "Failed create HMI text list:\n" + ex.Message);
                    return;
                }
            }
        }
 protected override void DoWork()
 {
     lock (portal)
     {
         try
         {
             PresetRecallSCL scl = new PresetRecallSCL(blockName, valueTypeName, enableTypeName, null);
             foreach (var tag in tags)
             {
                 scl.AddRecall(tag.tagPath);
             }
             TIAutils.ImportPlcBlockXML(scl.Document, resultGroup);
         }
         catch (Exception ex)
         {
             LogMessage(MessageLog.Severity.Error, "Failed to update preset recall SCL block:\n" + ex.Message);
             return;
         }
     }
 }
Beispiel #7
0
        private void exportButton_Click(object sender, EventArgs e)
        {
            if (savePresetList.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                try
                {
                    ConstantLookup constants = new ConstantLookup();
                    constants.Populate(tiaPortal, plcSoftware);

                    Dictionary <string, List <PresetTag> > tag_groups = tagGroups(presetList);

                    PlcBlockGroup plc_preset_group = plcSoftware.BlockGroup.Groups.Find("Preset");
                    if (plc_preset_group == null)
                    {
                        MessageBox.Show("No group named Preset found for PLC " + plcSoftware.Name);
                        return;
                    }
                    Dictionary <string, PresetGroup> preset_groups = new Dictionary <string, PresetGroup>();


                    foreach (string group_name in tag_groups.Keys)
                    {
                        PresetGroup group          = new PresetGroup();
                        string      preset_db_name = "sDB_Preset_" + group_name;
                        PlcBlock    preset_db      = plc_preset_group.Blocks.Find(preset_db_name);
                        if (preset_db == null)
                        {
                            MessageBox.Show("No block named " + preset_db_name + " found for PLC " + plcSoftware.Name);
                            return;
                        }
                        XmlDocument doc;
                        try
                        {
                            doc = TIAutils.ExportPlcBlockXML(preset_db);
                        }
                        catch (Exception ex)
                        {
                            MessageBox.Show("Failed to export block " + preset_db_name + ": " + ex.Message);
                            return;
                        }

                        if (doc.DocumentElement.SelectSingleNode("/Document/SW.Blocks.GlobalDB//if:Section[@Name='Static']", XMLUtil.nameSpaces) is XmlElement static_elem)
                        {
                            group.preset_names  = PresetValueParser.GetPresetNames(static_elem, constants);
                            group.preset_colors = PresetValueParser.GetPresetColors(static_elem, constants);
                            group.presets       = new List <PresetDocument.PresetInfo>();
                            var tags = tag_groups[group_name];
                            foreach (var tag in tags)
                            {
                                var values  = PresetValueParser.GetPresetValue(static_elem, tag.tagPath, constants);
                                var enabled = PresetValueParser.GetPresetEnabled(static_elem, tag.tagPath, constants);
                                Console.WriteLine(tag.tagPath + ":" + (string.Join(",", values)));
                                group.presets.Add(new PresetDocument.PresetInfo()
                                {
                                    tag = tag, values = values, enabled = enabled
                                });
                            }

                            preset_groups[group_name] = group;
                        }
                        else
                        {
                            MessageBox.Show("No static section found for " + preset_db_name);
                            return;
                        }
                    }



                    PresetDocument.Save(savePresetList.FileName, preset_groups, cultureComboBox.SelectedItem.ToString());
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Failed to export preset list: " + ex.Message);
                }
            }
        }
Beispiel #8
0
        private void WriteButton_Click(object sender, EventArgs e)
        {
            if (task_dialog == null)
            {
                task_dialog = new TaskDialog();
            }
            task_dialog.Clear();

            Project             proj  = tiaPortal.Projects[0];
            LanguageAssociation langs = proj.LanguageSettings.ActiveLanguages;

            string[] cultures        = langs.Select(l => l.Culture.Name).ToArray();
            string   default_culture = proj.LanguageSettings.ReferenceLanguage.Culture.Name;

            foreach (PresetTagList.Row row in presetList)
            {
                row.Tag.labels.AddMissingCultures(cultures, default_culture);
                if (row.Tag.state_labels != null)
                {
                    foreach (MultilingualText text in row.Tag.state_labels.Values)
                    {
                        text.AddMissingCultures(cultures, default_culture);
                    }
                }
            }
            // Sort the groups into separate lists of tags
            Dictionary <string, List <PresetTag> > tag_groups = tagGroups(presetList);


            ConstantLookup constants = new ConstantLookup();

            constants.Populate(tiaPortal, plcSoftware);

            // Create databases for all groups
            foreach (string group_name in tag_groups.Keys)
            {
                string db_name     = PRESET_DB_PREFIX + group_name;
                string hmi_db_name = PRESET_HMI_DB_PREFIX + group_name;
                var    tags        = tag_groups[group_name];

                string value_type_name  = "PresetValueType_" + group_name;
                string enable_type_name = "PresetEnableType_" + group_name;

                task_dialog.AddTask(new CreatePresetTypesTask(tiaPortal, tags, typeGroup, value_type_name, enable_type_name));
                string recall_block_name = "PresetRecall_" + group_name;
                task_dialog.AddTask(new CreatePresetRecallBlockTask(tiaPortal, tags, resultGroup, recall_block_name, value_type_name, enable_type_name));
                string store_block_name         = "PresetStore_" + group_name;
                string store_enabled_block_name = "PresetStoreEnabled_" + group_name;
                task_dialog.AddTask(new CreatePresetStoreBlockTask(tiaPortal, tags, resultGroup, store_block_name, store_enabled_block_name, value_type_name, enable_type_name));
            }

            task_dialog.AddTask(new CreatePlcCompileTask(tiaPortal, plcSoftware));

            foreach (HmiTarget hmi in hmiTargets)
            {
                // Create HMI tags
                TagFolder preset_tag_folder = hmi.TagFolder.Folders.Find("Preset");
                if (preset_tag_folder != null)
                {
                    task_dialog.AddTask(new CreateHmiPresetConstantTagsTask(tiaPortal, preset_tag_folder, constants));
                }
            }

            // Create HMI for all groups
            foreach (string group_name in tag_groups.Keys)
            {
                var    tags        = tag_groups[group_name];
                string db_name     = PRESET_DB_PREFIX + group_name;
                string hmi_db_name = PRESET_HMI_DB_PREFIX + group_name;

                foreach (HmiTarget hmi in hmiTargets)
                {
                    string            popup_name   = "PresetPopup_" + group_name;
                    ScreenPopupFolder popup_folder = hmi.ScreenPopupFolder;
                    ScreenPopup       popup        = popup_folder.ScreenPopups.Find(popup_name);
                    if (popup == null)
                    {
                        task_dialog.AddTask(new MessageTask("Skipping preset group " + group_name + " for HMI " + hmi.Name,
                                                            MessageLog.Severity.Info,
                                                            "Assuming preset group " + group_name + " is not used by this HMI since the pop-up screen " + popup_name + " was not found"));
                        continue;
                    }

                    String list_prefix = "PresetTextList_" + group_name + "_";
                    TextListComposition hmi_text_lists = hmi.TextLists;

                    // Text list that are candidates for deletion
                    List <String> delete_lists = new List <string>();
                    // Find all preset text lists
                    foreach (var list in hmi_text_lists)
                    {
                        if (list.Name.StartsWith(list_prefix))
                        {
                            delete_lists.Add(list.Name);
                        }
                    }

                    // Create text lists

                    int count = 1;
                    foreach (PresetTag tag in tags)
                    {
                        if (tag.state_labels != null)
                        {
                            string list_name = list_prefix + count;
                            delete_lists.Remove(list_name); // Don't delete this list
                            task_dialog.AddTask(new CreateHmiTextListTask(tiaPortal, list_name, hmi_text_lists, tag.state_labels));
                        }
                        count++;
                    }

                    // Delete old textlists
                    task_dialog.AddTask(new DeleteHmiTextListTask(tiaPortal, list_prefix, hmi_text_lists, delete_lists));

                    // Get number of presets configured
                    string count_entry_name          = "PresetCount_" + group_name;
                    ConstantLookup.Entry count_entry = constants.Lookup(count_entry_name);
                    if (count_entry == null)
                    {
                        throw new Exception("Global constant " + count_entry_name + " not found");
                    }


                    int nPresets = int.Parse(count_entry.value);

                    Dictionary <int, MultilingualText> preset_names = new Dictionary <int, MultilingualText>();
                    // Create preset name list


                    {
                        for (int p = 1; p <= nPresets; p++)
                        {
                            string           name_string = "<hmitag length='20' type='Text' name='PresetName_" + group_name + "_" + p + "'>Preset " + p + "</hmitag>";
                            MultilingualText text        = new MultilingualText();
                            foreach (string c in cultures)
                            {
                                text.AddText(c, name_string);
                            }
                            preset_names.Add(p, text);
                        }

                        string list_name = "PresetNameList_" + group_name;
                        task_dialog.AddTask(new CreateHmiTextListTask(tiaPortal, list_name, hmi_text_lists, preset_names));
                    }
                    // Create HMI tags
                    TagFolder preset_tag_folder = hmi.TagFolder.Folders.Find("Preset");
                    if (preset_tag_folder != null)
                    {
                        string table_name = "Preset_" + group_name;
                        task_dialog.AddTask(new CreatePresetHmiTagsTask(tiaPortal, tags, preset_tag_folder, table_name, group_name, db_name, hmi_db_name, nPresets));
                    }
                    else
                    {
                        MessageBox.Show("No HMI tag group name 'Preset' was found for HMI " + hmi.Name + ". No tag tables will be updated.");
                    }

                    // Load template screen

                    ScreenTemplate obj_templ = hmi.ScreenTemplateFolder.ScreenTemplates.Find("ObjectTemplate");
                    if (obj_templ != null)
                    {
                        XmlDocument templates = TIAutils.ExportScreenTemplateXML(obj_templ);

                        // Create popups
                        task_dialog.AddTask(new CreatePresetScreenPopupTask(tiaPortal, tags, popup_folder, templates, popup_name, group_name));
                    }
                    else
                    {
                        MessageBox.Show("No template screen named ObjectTemplate found for HMI " + hmi.Name + ". Some screens will not be updated.");
                    }
                }
            }


            task_dialog.Show();
        }
        protected override void DoWork()
        {
            lock (portal)
            {
                try
                {
                    ScreenPopup popup = folder.ScreenPopups.Find(popupName);

                    if (popup != null)
                    {
                        XmlDocument popup_doc = TIAutils.ExportScreenPopupXML(popup);
                        PresetPopup editor    = new PresetPopup(popup_doc, templates);
                        int         index     = 1;

                        foreach (var tag in tags)
                        {
                            DataType type = tag.tagPath.Type;
                            string   template;
                            if (tag.state_labels != null)
                            {
                                template = "PresetGroupState";
                            }
                            else if (type is Integer || type is BitString || type is REAL || type is LREAL)
                            {
                                template = "PresetGroupNumber";
                            }
                            else if (type is BOOL)
                            {
                                template = "PresetGroupBool";
                            }
                            else
                            {
                                template = "PresetGroupNoValue";
                            }


                            editor.AddEnableSelection(template, groupName, index, tag.labels, tag.unit, tag.precision);
                            index++;
                        }
                        // Remove extra groups

                        while (true)
                        {
                            String deleted = editor.RemoveEnableSelection(groupName, index);
                            if (deleted == null)
                            {
                                break;
                            }
                            LogMessage(MessageLog.Severity.Info, "Deleted entry group " + deleted);
                            index++;
                        }

                        TIAutils.ImportScreenPopupXML(popup_doc, folder);
                    }
                    else
                    {
                        LogMessage(MessageLog.Severity.Info, "Couldn't find popup " + popupName + ", skipping.");
                    }
                }
                catch (Exception ex)
                {
                    LogMessage(MessageLog.Severity.Error, "Failed to update popup screen:\n" + ex.Message);
                    return;
                }
            }
        }