Delmia Com二次开发

于 2020-09-09 22:19:12 发布
阅读量1.1k 收藏 3
点赞数
文章标签： DELMIA Com 二次开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qingyangwuji/article/details/108503692
版权
本文介绍了如何通过COM通信接口对DELMIA进行二次开发，实现环境标准化初始化，以及自动化配置仿真中的机器人，包括Object TCP、默认设置和Taglist，显著提高工作效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

通过Com 通讯方法对Delmia进行操作完成以下工作
1、初始化Delmia放在环境，保证环境标准化。
2、完成对仿真中的机器人进行操作，自动创建机器人Object TCP 等所有默认配置病完成设定的Taglist 和文件路径的个方面设置，大量节约时间

操作界面如下图：
在这里插入图片描述

程序头引用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using CATIA_APP_ITF;
using SURFACEMACHINING;
using System.Runtime.InteropServices;
using System.Net.Sockets;
using System.Threading;
using System.Net;
using System.Diagnostics;
using INFITF;
using MECMOD;
using PARTITF;
using ProductStructureTypeLib;
using SPATypeLib;
using NavigatorTypeLib;
using KnowledgewareTypeLib;
using HybridShapeTypeLib;
using System.IO;
using DNBPert;
using CATMat;
using FittingTypeLib;
using DNBASY;
using System.Windows.Forms;
using PROCESSITF;
using PPR;
using NPOI.POIFS.Crypt.Dsig;

class GloalForDelmia
    {
        /// <summary>
        /// 初始化软件环境及全局变量
        /// </summary>
        /// <param name="FM">当前From</param>
        /// <param name="SoftTarget">Catia/Delmia</param>
        /// <returns></returns>
        public DataType.Dsystem InitCatEnv(Form FM)
        {
            DataType.Dsystem  Dsvalue= new DataType.Dsystem();
            INFITF.Application DSApplication;
            Documents DSDocument;
            ProcessDocument DSActiveDocument;
            Process[] AllProcess = Process.GetProcessesByName("DELMIA");
            if (AllProcess.Length>1)
            {
                try
                {
                   // MessageBox.Show("当前打开超过1个Delmia,可能操控的Delmia非您需要的对象，请核实！");
                   // IntPtr Ptr = AllProcess[2].MainWindowHandle;
                   // string Pname = AllProcess[2].MainWindowTitle;
                   //  int progid=  AllProcess[2].;
                   // object Pobj = Marshal.GetActiveObject("Delmia.Application");
                    object Tobj = Marshal.GetObjectForIUnknown(ptr2);
                   // object Pobj0 = Marshal.GetActiveObject(progid.ToString());
                   // DSApplication = (INFITF.Application)Pobj;
                   // String tn = DSApplication.get_Caption();
                }
                catch (Exception)
                {
                    throw;
                }
            }
            try
            {
                DSApplication = (INFITF.Application)Marshal.GetActiveObject("Delmia.Application");
            }
            catch (Exception)
            {
                FM.WindowState = FormWindowState.Normal;
                FM.StartPosition = FormStartPosition.CenterScreen;
                MessageBox.Show("未检测到打开的Delmia!,请重新运行Delmia!");
                Dsvalue.Revalue = -1;
                return Dsvalue;
                //throw;
            }
            DSApplication.set_Caption("正在运行瑞祥快速建模工具！");
            // 获取当前活动ProductDocument
            try
            {
                DSDocument = (Documents)DSApplication.Documents;
                DSActiveDocument = (ProcessDocument)DSApplication.ActiveDocument;
            }
            catch (Exception)
            {
                    MessageBox.Show("未检测到活动Product,正在为您创建，请手动辅助完成！");
                    Dsvalue.Revalue = -1;
                    return Dsvalue;
                //MessageBox.Show("未检测到活动Product,已自动为您创建对象！");
            }
            // 添加一个新零件
            Dsvalue.DSApplication = DSApplication;
            Dsvalue.DSDocument = DSDocument;
            Dsvalue.DSActiveDocument = DSActiveDocument;
            Dsvalue.Revalue = 0;
            return Dsvalue;
        }
        public Selection GetInitTargetProduct(Form FM, DataType.Dsystem DSystem)
        {
            FM.WindowState = FormWindowState.Minimized;
            INFITF.Application CatApplication=DSystem.DSApplication;
            ProcessDocument PPRP = DSystem.DSActiveDocument;
            Selection USelect= PPRP.Selection;
            USelect.Clear();
            var Result = USelect.SelectElement2(DataType.InputObjectType(9), "请选择初始化对象", true);
            if (Result == "Cancel")
            {
                return null;
            }
            if (USelect.Count < 1)
            {
                MessageBox.Show("请先选择对象后再点此命令！");
                return null;
            }
            return USelect;
        }
        public Selection GetIRobotMotion(Form FM, DataType.Dsystem DSystem)
        {
            FM.WindowState = FormWindowState.Minimized;
            INFITF.Application CatApplication = DSystem.DSApplication;
            ProcessDocument PPRP = DSystem.DSActiveDocument;
            Selection USelect = PPRP.Selection;
            USelect.Clear();
            var Result = USelect.SelectElement2(DataType.InputObjectType(9), "请选择一个机器人", true);
            if (Result == "Cancel")
            {
                return null;
            }
            if (USelect.Count < 1)
            {
                MessageBox.Show("请先选择对象后再点此命令！");
                return null;
            }
            return USelect;
        }

 class DataType
    {
     
        /// <summary>
        /// 达索关键值传送器
        /// </summary>
        public class Dsystem
        {
            /// <summary>
            /// 活动Application
            /// </summary>
            public virtual INFITF.Application DSApplication { get; set; }
            public virtual ProcessDocument DSPPRProduct { get; set; }
            public virtual  PPRDocument DsPPRDocument { get; set; }
            public virtual Resources DSResources { get; set; }
            /// <summary>
            /// 活动Document
            /// </summary>
            public virtual Documents DSDocument { get; set; }
            public virtual ProcessDocument DSActiveDocument { get; set; }
            /// <summary>
            /// 自定义的零件
            /// </summary>
            public virtual Part PartID{ get; set; }
            /// <summary>
            /// 用户选择集
            /// </summary>
            public virtual Selection  USelection { get; set; }
            /// <summary>
            /// -1 ERR;0 Normal
            /// </summary>
            public virtual int Revalue { get; set; }
        }
        /// <summary>
        /// 设置CATIA 拾取对象类型
        /// 0：GetAnyObject；1：GetPoint；2:Face；3:Edge；4:Pad；5:sketch；6:Shape；7:Bodies；8:Part；9：Product
        /// </summary>
        /// <returns>:</returns>
        [return: MarshalAs(UnmanagedType.SafeArray, SafeArraySubType = VarEnum.VT_VARIANT)]
       static public object[] InputObjectType(int ReadType)
        {
            switch (ReadType)
            {
                case 0: //GetAnyObject
                    {
                        return new object[] { "AnyObject" };
                    }
                case 1: //GetPoint
                    {
                        return new object[] { "Point", "Symmetry", "Translate" };
                    }
                case 2: //Face
                    {
                        return new object[] { "Face" };
                    }
                case 3: //Edge
                    {
                        return new object[] { "Edge" };
                    }
                case 4: //Pad
                    {
                        return new object[] { "Pad" };
                    }
                case 5: //sketch
                    {
                        return new object[] { "sketch" };
                    }
                case 6: //Shape
                    {
                        return new object[] { "Shape" };
                    }
                case 7: //Bodies
                    {
                        return new object[] { "Bodies" };
                    }
                case 8: //Part
                    {
                        return new object[] { "Part" };
                    }
                case 9: //Product
                    {
                        return new object[] { "Product" };
                    }
                case 10: //RobotMotion
                    {
                        return new object[] { "RobotMotion" };
                    }
                case 11: //Robot 
                    {
                        return new object[] { "Robot" };
                    }
                case 12: //RobotTask
                    {
                        return new object[] { "RobotTask" };
                    }
                case 13: //Resource
                    {
                        return new object[] { "Operation" };
                    }
                default:
                    return new object[] { "AnyObject" };
            }
        }
        public class SimulationDir
        {
            public string MBPath { get; set; }
            public string SBRPath { get; set; }
            public string SBLPath { get; set; }
            public string FRPath { get; set; }
            public string RRPath { get; set; }
            public string UBPath { get; set; }
            public string STPath { get; set; }
            public string SMPath { get; set; }
            public string LayoutPath { get; set; }
        }
    }

 private void InitRobot_Click(object sender, EventArgs e)
        {
            Pbar.Value = 0;
            Pbar.Step = 10;
            GloalForDelmia GFD = new GloalForDelmia();
            DStype = GFD.InitCatEnv(this);
            if (DStype.Revalue == -1)
            {
                return;
            }
            Selection Uselect = GFD.GetIRobotMotion(this, DStype);
            Product Usp = null;
            if (Uselect != null && Uselect.Count > 0)
            {
                try
                {
                    String GetName = string.Empty;
                    Usp = (Product)Uselect.Item2(1).Value;
                    GetName = Usp.get_Name();
                    RobGenericController Rgcr = (RobGenericController)Usp.GetTechnologicalObject("RobGenericController");
                    RobControllerFactory CRM = (RobControllerFactory)Usp.GetTechnologicalObject("RobControllerFactory");
                    GetName = CRM.get_Name();
                    #region 机器人基本TCP Motion初始化
                    for (int i = 1; i <= Convert.ToInt16(RobotCtrlNum.Text); i++)
                    {
                        GenericAccuracyProfile GP;
                        GenericMotionProfile GMP;
                        GenericToolProfile GTP;
                        GenericObjFrameProfile GOP;
                        bool ExistsObject;
                        CRM.CreateGenericAccuracyProfile(out GP);
                        GP.GetName(ref GetName);
                        GetName = CRM.get_Name();
                        GP.SetAccuracyValue(i * 0.1);
                        GP.SetName(i * 10 + "%");
                        GP.SetAccuracyType(AccuracyType.ACCURACY_TYPE_SPEED);
                        GP.SetFlyByMode(false);
                        Rgcr.HasAccuracyProfile((i * 10 + "%"), out ExistsObject);
                        if (!ExistsObject)
                        {
                            Rgcr.AddAccuracyProfile(GP);
                        }
                        Pbar.PerformStep();
                        /
                        CRM.CreateGenericObjFrameProfile(out GOP);
                        GOP.SetObjectFrame(0, 0, 0, 0, 0, 0);
                        GOP.SetName("Object_0" + i);
                        Rgcr.HasObjFrameProfile(("Object_0" + i), out ExistsObject);
                        if (!ExistsObject)
                        {
                            Rgcr.AddObjFrameProfile(GOP);
                        }
                        Pbar.PerformStep();
                        /
                        CRM.CreateGenericMotionProfile(out GMP);
                        GMP.SetSpeedValue(i * 0.1);
                        GMP.SetName(i * 10 + "%");
                        GMP.SetMotionBasis(MotionBasis.MOTION_PERCENT);
                        Rgcr.HasMotionProfile((i * 10 + "%"), out ExistsObject);
                        if (!ExistsObject)
                        {
                            Rgcr.AddMotionProfile(GMP);
                        }
                        Pbar.PerformStep();
                        /
                        // NwName = i < 9 ? ("Tool_0" + i) : ("Tool_" + i);
                        string NwName = "Tool_0" + i;
                        Rgcr.HasToolProfile(NwName, out ExistsObject);
                        if (!ExistsObject)
                        {
                            try
                            {
                                int ToolNum = 0;
                                Rgcr.GetToolProfileCount(out ToolNum);
                                string Ctname = string.Empty;
                                if (ToolNum < 16)
                                {
                                    CRM.CreateGenericToolProfile(out GTP);
                                    Rgcr.AddToolProfile(GTP);
                                    //Object[] ToolLists = new object[ToolNum];
                                    //Rgcr.GetToolProfiles(ToolLists);
                                    //for (int j = 1; j <= ToolNum; j++)
                                    //{
                                    //    Ctname = ((GenericToolProfile)ToolLists[i]).get_Name();
                                    //    ((GenericToolProfile)ToolLists[i]).set_Name(NwName);
                                    //}
                                    //GTP.GetName(Ctname);
                                    //GTP.SetToolMobility(true);
                                    //GTP.set_Name(NwName);
                                }
                            }
                            catch (Exception)
                            {
                                throw;
                            }
                            //Object[] TooList = new object[99];
                            //Rgcr.GetToolProfiles(TooList);
                            //int TotalTool;
                            //Rgcr.GetToolProfileCount(out TotalTool);
                            //GenericToolProfile ToolProfile =(GenericToolProfile)TooList[TotalTool-1];
                            //NwName = ToolProfile.get_Name();
                            //ToolProfile.set_Name(NwName);
                        }
                        Pbar.PerformStep();
                    }
                    #endregion
                    #region 机器人默认值设置
                    //Init Current Motion Profile \accuracy \ Tool Profile \Object
                    bool ExistsObj;
                    Rgcr.HasAccuracyProfile((100 + "%"), out ExistsObj);
                    if (ExistsObj)
                    {
                        Rgcr.SetCurrentAccuracyProfile((100 + "%"));
                    }
                    Rgcr.HasObjFrameProfile("Object_01", out ExistsObj);
                    if (ExistsObj)
                    {
                        Rgcr.SetCurrentObjFrameProfile("Object_01");
                    }
                    Rgcr.HasMotionProfile((100 + "%"), out ExistsObj);
                    if (ExistsObj)
                    {
                        Rgcr.SetCurrentMotionProfile((100 + "%"));
                    }
                    Rgcr.HasToolProfile("Tool_01", out ExistsObj);
                    if (ExistsObj)
                    {
                        Rgcr.SetCurrentToolProfile("Tool_01");
                    }
                    #endregion
                    #region 机器日Taglist目录及RobotTask批量设置
                    RobotTaskFactory Rtf = (RobotTaskFactory)Usp.GetTechnologicalObject("RobotTaskFactory");
                    object[] RobotTaskLists = new object[99];
                    try
                    {
                        Rtf.GetAllRobotTasks(RobotTaskLists);
                    }
                    catch (Exception)
                    {
                        RobotTaskLists = null;
                    }
                    GetName = Rtf.get_Name();
                    if (GPWeld.Checked)
                    {
                        String RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_" + ModelName.Text.ToUpper() + "_GP" + "_" + ELEID.Text;
                        if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                        {
                            Rtf.CreateRobotTask(RobotTaskName, null);
                            Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                            AddTagToRobotTask(Rtf, RobotTaskName, tag);
                        }
                        if (GunStand.Checked)
                        {
                            RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_GUN" + "_" + ELEID.Text + "_Pick";
                            if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                            {
                                Rtf.CreateRobotTask(RobotTaskName, null);
                                Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                                AddTagToRobotTask(Rtf, RobotTaskName, tag);
                            }
                            RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_GUN" + "_" + ELEID.Text + "_Drop";
                            if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                            {
                                Rtf.CreateRobotTask(RobotTaskName, null);
                                Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                                AddTagToRobotTask(Rtf, RobotTaskName, tag);
                            }
                        }
                    }
                    Pbar.PerformStep();
                    if (RPWeld.Checked)
                    {
                        String RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_" + ModelName.Text.ToUpper() + "_RP" + "_" + ELEID.Text;
                        if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                        {
                            Rtf.CreateRobotTask(RobotTaskName, null);
                            Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                            AddTagToRobotTask(Rtf, RobotTaskName, tag);
                        }
                    }
                    Pbar.PerformStep();
                    if (Glue.Checked)
                    {
                        String RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_" + ModelName.Text.ToUpper() + "_Glue" + "_" + ELEID.Text;
                        if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                        {
                            Rtf.CreateRobotTask(RobotTaskName, null);
                            Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                            AddTagToRobotTask(Rtf, RobotTaskName, tag);
                        }
                    }
                    Pbar.PerformStep();
                    if (PickAndUp.Checked)
                    {
                        String RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_" + ModelName.Text.ToUpper() + "_Gripper" + "_" + ELEID.Text;
                        if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                        {
                            Rtf.CreateRobotTask(RobotTaskName, null);
                            Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                            AddTagToRobotTask(Rtf, RobotTaskName, tag);
                        }
                        if (GrpStand.Checked)
                        {
                            RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_Grip" + "_" + ELEID.Text + "_Pick";
                            if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                            {
                                Rtf.CreateRobotTask(RobotTaskName, null);
                                Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                                AddTagToRobotTask(Rtf, RobotTaskName, tag);
                            }
                            RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_Grip" + "_" + ELEID.Text + "_Drop";
                            if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                            {
                                Rtf.CreateRobotTask(RobotTaskName, null);
                                Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                                AddTagToRobotTask(Rtf, RobotTaskName, tag);
                            }
                        }
                    }
                    Pbar.PerformStep();
                    if (StudWeld.Checked)
                    {
                        String RobotTaskName = ((Product)((Product)Usp.Parent).Parent).get_PartNumber() + "_" + RobotID.Text.ToUpper() + "_" + ModelName.Text.ToUpper() + "_Stud" + "_" + ELEID.Text;
                        if (!CheckTaskExists(RobotTaskLists, RobotTaskName))
                        {
                            Rtf.CreateRobotTask(RobotTaskName, null);
                            Tag tag = NwSingleTagGroup(((Product)((Product)Usp.Parent).Parent), RobotTaskName);
                            AddTagToRobotTask(Rtf, RobotTaskName, tag);
                        }
                    }
                    Pbar.PerformStep();
                    #endregion
                    object[] RTask = new object[50];
                    Rtf.GetAllRobotTasks(RTask);
                    foreach (RobotTask item in RTask)
                    {
                        if (item != null)
                        {
                            item.set_Description("安徽瑞祥工业自动化产品，机器人轨迹,创建于:" + DateTime.Now);
                        }
                    }
                    //DeviceTaskFactory DTF= (DeviceTaskFactory)Usp.GetTechnologicalObject("DeviceTaskFactory");
                    //DeviceTask DT=null;
                    //DTF.CreateDeviceTask("YECCNewTask",ref DT);
                    Usp.Update();
                }
                catch (Exception)
                {
                    //throw;
                    this.TopMost = true;
                    MessageBox.Show("您选择的不是一个运动机构！");
                }
                SethomePositiion(Usp);
            }
            Pbar.PerformStep();
            Pbar.Value = 100;
            this.WindowState = FormWindowState.Normal;
            this.StartPosition = FormStartPosition.CenterScreen;
            this.TopMost = true;
        }

 private bool SethomePositiion(Product product)
        {
            return true; // Not Support Again
            try
            {
                BasicDevice basicDevice = (BasicDevice)product.GetTechnologicalObject("BasicDevice");
                DeviceSim deviceSim = (DeviceSim)product.GetTechnologicalObject("DeviceSim");
                Mechanisms mechanisms = (Mechanisms)product.GetTechnologicalObject("Mechanisms");
                //Mechanism deviceSim1 = null;
                //try
                //{
                //    int cnt = mechanisms.Count;
                //    string str = mechanisms.Name;
                //    object msobj = 1;
                //    mechanisms.Item(ref msobj);
                //}
                //catch (Exception e)
                //{
                //    throw e;
                //    //If there are no mechanisms (i.e. D5 devices), use the device handle instead
                //    string  s = mechanisms.Item(1).get_Name();
                //}
                Array HomePosition = new object[] { };
                basicDevice.GetHomePositions(out HomePosition);
                bool exithome = false;
                foreach (HomePosition item in HomePosition)
                {
                    //Array DofValue0 = new object[] { };
                    //item.GetDOFValues(out DofValue0);
                    if (item.get_Name() == "home_1")
                    {
                        exithome = true;
                    }
                }
                if (!exithome)
                {
                    Array DofValue = new object[] { 0, 0, 0, 0, -1.5707963267949054, 0 };
                    basicDevice.SetHomePosition("home_1", DofValue);
                    //deviceSim.SetDOFValues(deviceSim1, DofValue, true);
                    return true;
                }
                return false;
            }
            catch (Exception)
            {
                return false;
            }
        }

 /// <summary>
        /// 检查机器人程序是否重复
        /// </summary>
        /// <param name="RobotTaskList">机器人程序集</param>
        /// <param name="CheckedName">检查是否存在的程序名称</param>
        /// <returns></returns>
        private bool CheckTaskExists(Object[] RobotTaskList, string CheckedName)
        {
            if (RobotTaskList == null)
            {
                return false;
            }
            foreach (RobotTask item in RobotTaskList)
            {
                if (item != null)
                {
                    String taskName = item.get_Name();
                    if (taskName == CheckedName)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        private bool AddTagToRobotTask(RobotTaskFactory robotTaskFactory, String RobotTaskName, Tag tag)
        {
            object[] RobotTaskLists = new object[99];
            try
            {
                robotTaskFactory.GetAllRobotTasks(RobotTaskLists);
            }
            catch (Exception)
            {
                return false;
            }
            foreach (RobotTask item in RobotTaskLists)
            {
                if (item != null)
                {
                    String taskName = item.get_Name();
                    if (taskName == RobotTaskName)
                    {
                        RobotTask robotTask = item;
                        Operation objoperation;
                        objoperation = null;
                        robotTask.CreateOperation(null, null, ref objoperation);
                        AnyObject ObjRM = null;
                        RobotMotion robotMotion = null;
                        objoperation.CreateRobotMotion(ObjRM, true, ref robotMotion);
                        //Object[] RMobj = new object[6] { 0, 0, 0, 0, -1.5707963267949054, 0 };
                        robotMotion.SetTagTarget(tag);
                        //robotMotion.GetJointTarget(RMobj);
                        //robotMotion.SetJointTarget(RMobj);
                        //robotMotion.GetCartesianTarget(RMobj);
                        tag.SetName("RefPoint");
                        robotMotion.SetTagTarget(tag);
                        return true;
                    }
                }
            }
            return true;
        }
        private void ModelName_TextChanged(object sender, EventArgs e)
        {
            Properties.Settings.Default.ModelName = ModelName.Text;
            Properties.Settings.Default.Save();
        }
        private void RobotID_TextChanged(object sender, EventArgs e)
        {
            Properties.Settings.Default.RobotID = RobotID.Text; ;
            Properties.Settings.Default.Save();
        }
        private void ELEADD_Click(object sender, EventArgs e)
        {
            int CV = Convert.ToInt16(ELEID.Text);
            CV += 1;
            CV = CV < 1 ? 1 : CV;
            String TV = CV < 10 ? (0 + CV.ToString()) : CV.ToString();
            ELEID.Text = TV;
        }
        private void ELEREMOVE_Click(object sender, EventArgs e)
        {
            int CV = Convert.ToInt16(ELEID.Text);
            CV -= 1;
            CV = CV < 1 ? 1 : CV;
            String TV = CV < 10 ? (0 + CV.ToString()) : CV.ToString();
            ELEID.Text = TV;
        }
        private void ManuleInit_Click(object sender, EventArgs e)
        {
            INITCtrol();
        }
        private void BackForm_Click(object sender, EventArgs e)
        {
            Main CMain = new Main();
            this.Hide();
            CMain.Show();
        }
        private void BallToRobotList_Click(object sender, EventArgs e)
        {
            int CV = Convert.ToInt16(RobotID.Text);
            CV += 1;
            CV = CV < 1 ? 1 : CV;
            String TV = CV < 10 ? (0 + CV.ToString()) : CV.ToString();
            ELEID.Text = TV;
        }

        private void StationNumAdd_Click(object sender, EventArgs e)
        {
            char[] ValueStr = RobotID.Text.ToCharArray();
            int CV = Convert.ToInt16(ValueStr[1].ToString());
            int RV = Convert.ToInt16(ValueStr[2].ToString());
            //CV += 1;
            CV = CV < 9 ? CV += 1 : 9;
            CV = CV < 1 ? 1 : CV;
            String TV = "R" + CV.ToString() + RV;
            RobotID.Text = TV;
        }

        private void StationNumRemove_Click(object sender, EventArgs e)
        {
            char[] ValueStr = RobotID.Text.ToCharArray();
            int CV = Convert.ToInt16(ValueStr[1].ToString());
            int RV = Convert.ToInt16(ValueStr[2].ToString());
            CV -= 1;
            CV = CV < 1 ? 1 : CV;
            String TV = "R" + CV.ToString() + RV;
            RobotID.Text = TV;

        }

        private void RobotAdd_Click(object sender, EventArgs e)
        {
            char[] ValueStr = RobotID.Text.ToCharArray();
            int RV = Convert.ToInt16(ValueStr[1].ToString());
            int CV = Convert.ToInt16(ValueStr[2].ToString());
            //CV += 1;
            CV = CV < 9 ? CV += 1 : 9;
            CV = CV < 1 ? 1 : CV;
            String TV = "R" + RV + CV.ToString();
            RobotID.Text = TV;
        }

        private void RobotRemove_Click(object sender, EventArgs e)
        {
            char[] ValueStr = RobotID.Text.ToCharArray();
            int RV = Convert.ToInt16(ValueStr[1].ToString());
            int CV = Convert.ToInt16(ValueStr[2].ToString());
            CV -= 1;
            CV = CV < 1 ? 1 : CV;
            String TV = "R" + RV + CV.ToString();
            RobotID.Text = TV;
        }
    }
博客
Plant Simulation 基于Windows消息系统跨线程通讯方案
05-10 293
方案2:如果实在不想浪费开辟共享内存的开销使用也可以使用SendMessage方式 但是需要将消息Append到目标句柄 hmodule 的后方，PlantSimulation.dll 在解析完自己需要的参数后，会自动将指针后移到用户实际数据部分。推荐使用 安徽锐锋科技 提供的重构的参数接口。
博客
# 安徽锐锋科技IDMS系统简介
01-23 1171
欢迎大家在此评论及交流学习 如有相关需求请联系我们！
博客
TPS使用底层(C++)ODBC完成数据库的增删改查-1
07-27 285
在上面的连接字符串中，您需要将server_name替换为实际的服务器名称，database_name替换为实际的数据库名称，username替换为实际的用户名，password替换为实际的密码。要在SQLDriverConnect中自动链接而不弹出对话框，您需要提供连接字符串中的所有必需参数。请注意，上述示例代码中的henv是先前分配的环境句柄。您还需要根据您使用的数据库驱动程序进行适当的更改。“SQLCHAR *” 类型的实参与 “SQLWCHAR *” 类型的形参不兼容。
博客
SQLite FTS5 扩展
05-17 2306
FTS5 是一个 SQLite 虚拟表模块，为数据库应用程序提供全文搜索功能。在最基本的形式中， 全文搜索引擎允许用户有效地搜索大型 包含一个或多个 搜索词。谷歌提供给万维网用户的搜索功能是全文搜索。引擎，因为它允许用户搜索网络上包含的所有文档， 例如，术语“FTS5”。要使用 FTS5，用户需要创建一个包含一个或多个 FTS5 虚拟表 列。例如：将类型、约束或主键声明添加到 用于创建 FTS5 表的创建虚拟表语句。
博客
PlantSimulation属性操作全家桶
04-26 1127
PlantSimulation属性操作<Path>.getAttributeName(Position:integer) → string<Path>.getAttributeValue(Parameter:any) → string<Path>.getAttrName(AttributeNumber:integer) → string<Path>.getAttrNo(AttributeName:string) → integer<Pa
博客
关于PlantSimulation 3D界面灰黑色解决方案
10-23 2603
关于PlantSimulation 3D界面灰黑色解决方案不知道大家有没有遇到过PlantSimulation 3D模式下黑屏问题，现象如下图：发生这个问题主要是因为我们选择了不合适的OpenGL 版本导致的：设置方法如下：如下图 需要选择自己合适的OpenGL版本即可，我的笔记本是3060 但是选择超过4.1版本后就会出现不同层次的黑屏现象。虽然版本越高 功能和性能越高，但是匹配才是最重要的。各版本OpenGL说明：详细信息可查看下面链接：https://www.cnblogs.com
博客
PlantSimulation预定义异常处理及捕获
09-27 960
函数 setErrorHandler 将您作为数据类型对象参数输入的 Method 设置为全局错误处理方法。当 SimTalk 方法中出现运行时错误时，它会禁止打开调试器。这个全局错误处理方法只会在程序没有找到单独的异常处理方法时才会执行当您设置全局错误处理方法时，当 SimTalk 方法中发生运行时错误时，将调用此方法。传递给该方法的三个参数：•带有错误消息的字符串。您必须将字符串参数声明为按引用参数。• 带有错误方法路径的字符串。• 一个整数值，表明哪一行包含错误。函数setErrorHan
博客
PlantSimulation中4中移动对象的方法对比
07-17 2190
insert 移动对象句法.insert([Target:any, Position:length, ConveyingDirection:integer]) → boolean方法 insert 将 指定的 MU 完全放置到参数 any 指定的目标对象上。• 对于面向点的对象，行为与move 和transfer 方法相同。• 对于面向长度的对象，MU 也会移动到指定的目标对象上，前提是它提供了足够的空间。如果指定的目标对象没有提供足够的空间，Plant Simulation 会尝试将 MU 的
博客
Backwards对自动路由的影响
05-21 164
自动路由导航系统中，将某一段路径设置为Backwards（反向）并不会影响`RouteToDes
博客
人员管理2302版本
05-19 42
本文介绍了三种人员管理方案：全自动、半自动和全人工管理。全自动方案未提供具体代码，但预计通过自动化系统实现人员调度。半自动方案通过代码实现，使用broker对象获取服务提供者，并通过条件判断和broker的engage方法进行任务分配。全人工方案则通过代码手动管理人员，禁用自动调度功能，并手动指派人员到指定工作地点。三种方案分别适用于不同自动化需求的管理场景，全自动方案适合高度自动化环境，半自动方案结合了自动化和人工干预，而全人工方案则完全依赖手动操作。
博客
自定义库模块增加自定义许可操作详细方法
05-17 1081
本文介绍了在自定义库模块中增加自定义许可操作的详细方法，主要涉及两个关键函数：setRequiredLicense 和 checkForLicense。setRequiredLicense 用于设置库加载时的密钥检查，确保密钥正确、版本匹配且未过期，否则无法加载。该函数支持设置许可证功能名称、版本号、密码等参数，并可添加自定义提示信息。checkForLicense 用于检查密钥的有效性，支持初始化时调用，并返回不同错误代码以提示具体问题，如未注册的许可证、主机ID错误、许可证过期等。通过这两个函数，可以有
博客
PlantSimulation 隐藏 Frame节点（Structure）的操作方法
05-14 45
在PlantSimulation中隐藏Frame节点（Structure）的操作方法如下：首先，确保封装的Frame已开启LockStructure功能。其次，Frame必须放置在库中，并且该库需要设置密码进行加密（密码不能为空）。通过这些步骤，可以实现Frame节点的隐藏。此外，若需隐藏文件夹，只需在文件夹属性中激活“HiddenWhenInLockedFolder”选项即可。这些操作有助于在PlantSimulation中管理和保护模型结构。
博客
使用定时器监视当前PID 如果当前程序关闭 UI_Core.exe 也随之自动关闭实现方法
05-10 457
C++20 QT6.9 VS2022 中使用QProcess::startDetached(“UI_Core.exe”, QStringList(), QString(), &UI_Manage_pid);是启动目标程序 能否同时告诉目标程序当前宿主程序的PID,在UI_CORE.EXE中 使用定时器监视当前PID 如果当前程序关闭 UI_Core.exe 也随之自动关闭 如何实现。这样，UI_Core.exe 就能在宿主进程意外退出或被正常关闭时，自己检测到并自动退出，保证不会在后台孤儿运行。
博客
针对共享内存和上述windows消息机制 在C++ 和qt之间的案例 进行详细举例说明
05-08 275
在此示例中，写入端将 QImage 序列化并写入共享内存，读取端从共享内存中读取并反序列化为 QImage。在此示例中，发送端使用 PostMessage 向目标窗口发送自定义消息，接收端在窗口过程函数中处理该消息。以下是关于在 C++ 和 Qt 中使用共享内存（QSharedMemory）和 Windows 消息机制（SendMessage / PostMessage）进行跨线程或跨进程通信的详细示例。线程间通信：对于线程间通信，Qt 提供了信号与槽机制，通常比共享内存或消息机制更为安全和高效。
博客
跨线程和跨进程通信还有多种方式对比
05-08 248
进程间通信：可以考虑命名管道、共享内存、消息队列、Socket、COM/DCOM 等方式，选择应基于数据量、实时性和平台兼容性等因素。请根据您的具体应用需求、平台和性能要求选择合适的通信机制。线程间通信：推荐使用 PostMessage、事件、互斥锁、信号量等机制，具体选择取决于同步需求和性能要求。分布式系统：消息中间件（如 RabbitMQ、Kafka）适用于大规模分布式系统中的异步通信和消息传递。跨平台通信：推荐使用 Socket、ZeroMQ、gRPC 等方式，具有良好的跨平台支持和扩展性。
博客
函数申明 Q_INVOKABLE
05-07 322
Q_INVOKABLE 是 Qt 提供的一个宏，主要用于 使成员函数能够被 Qt 的元对象系统（Meta-Object System）识别和调用。Q_INVOKABLE 是让一个普通成员函数进入 Qt 的“反射系统”，你可以通过字符串名字动态调用它，它在跨线程、QML 调用、脚本式引擎中非常有用。Q_INVOKABLE 只是告诉 Qt 元对象系统：“我想让这个函数能被反射式调用”。能够被 Qt QML 引擎识别（如果你在用 QML）；可以跨线程使用信号/槽机制以外的方式调用。
博客
Qt 中信号与槽（signal-slot）机制支持 多种连接方式（ConnectionType）
05-07 651
Qt 中信号与槽（signal-slot）机制支持 多种连接方式（ConnectionType），用于控制信号发出后如何调用槽函数，特别是在 跨线程 情况下。行为：不是独立的调用方式，而是一个 标志位，可与其他连接类型组合使用（例如 Qt::QueuedConnection | Qt::UniqueConnection）。行为：异步调用，即信号发出时不会立即执行槽函数，而是将槽函数调用封装成事件，放入接收者线程的事件队列中。槽函数在接收者线程中执行，但 发出信号的线程会阻塞，直到槽函数执行完毕。
博客
详细讲解 QMutex 线程锁和 QMutexLocker 自动锁的区别
04-24 350
QMutex 是线程同步的低层工具，QMutexLocker 是安全易用的高级封装，两者结合使用，可以轻松保障多线程 Qt 应用的线程安全。如果中间代码 throw 出异常，或者你忘记调用 unlock()，程序就会死锁（锁永远不释放）。QMutexLocker 是 Qt 提供的一个RAII（资源自动管理）类，用于自动加锁和解锁。QMutex 是 Qt 中的互斥锁（mutex）类，用于防止多个线程同时访问共享资源。避免手动管理锁，保证锁一定会释放（即使中途抛异常）。✍️ 示例场景：线程安全的缓存操作。
博客
New and Changed SimTalk Features 2504
04-24 502
【代码】New and Changed SimTalk Features 2504。
博客
Plant Simulation 2504正式增加Omniverse支持
04-24 219
近期采购Plant Simulation 的企业推荐采购 2504版本，可以支持Omniverse。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值