CN115502980A - Method, device, equipment and medium for controlling a mechanical arm - Google Patents

Abstract

The present application provides a method, device, device, and medium for manipulator control, which relate to the field of manipulator control. The method includes: obtaining a target plug-in interface corresponding to at least one functional class included in the manipulator control program; after exposing the target plug-in interface, Obtain the target custom program and/or target library file that meets the user's robotic arm control requirements; obtain the instantiation pointer corresponding to the target custom program based on the target custom program and/or target library file; The instantiated pointer runs a custom program to control the target robotic arm. This application implements at least one functional class contained in the robot arm control program as a target plug-in interface, so that users can develop a target custom program that meets the requirements of the robot arm control based on the target plug-in interface, and realizes the control of the target robot arm, avoiding the need for The problem of control program redundancy, the control process does not require users to send instructions, reducing the control delay.

Description

Method, device, equipment and medium for controlling a mechanical arm

technical field

The present application relates to the technical field of manipulator control, and in particular to a manipulator control method, device, equipment and medium.

Background technique

The process of the user operating the robotic arm includes: the user operates the client, and the client communicates with the robotic arm control program through the developed sdk interface to realize the control of the robotic arm.

However, there may be some requirements in the scenario where the user uses the robotic arm, such as adding two axes and forming an eight-axis linkage with the robotic arm. The current robotic arm control program does not provide an sdk interface for these requirements, so it can only be obtained through Additional programs are added to the source code of the manipulator control program to newly develop an sdk interface suitable for new requirements to meet user needs. However, the needs of users are ever-changing, and the excessive development of the control program of the manipulator makes the control program of the manipulator more and more redundant. In addition, the interaction between the client and the robotic arm control program is realized through the sdk interface. For some high-performance requirements, the delay is high. For example, the user needs to operate the robotic arm in real time, but the sdk interface allows the user to issue commands and the robotic arm responds to commands. There is high latency and poor user experience.

Contents of the invention

In view of this, the present application provides a method, device, device and medium for manipulator control, which are used to solve the problem of program redundancy caused by modifying the source code of the manipulator control program in the prior art and the problems caused by sending instructions through the sdk interface. For the problem of high delay, the technical solution is as follows:

A method for controlling a robotic arm, comprising:

Obtain the target plug-in interface corresponding to at least one functional class contained in the robotic arm control program, and expose the target plug-in interface corresponding to at least one functional class, wherein the target plug-in interface is used to call the robotic arm through the instantiation pointer of at least one functional class A program of at least one functional class contained in the control program, any one of the at least one functional class is used to control the target robotic arm to realize the corresponding function;

After exposing the target plug-in interface, obtain the target custom program and/or target library file that meets the user's robotic arm control requirements, where the library file is a library file compiled based on the target custom program, and the target custom program refers to a target custom program based on Inherit and implement the target plugin interface to get custom programs;

Obtain an instantiation pointer corresponding to the target custom program based on the target custom program and/or the target library file;

Run the target custom program based on the instantiation pointer corresponding to the target custom program to control the target robotic arm.

Optionally, obtain the target plug-in interface corresponding to at least one functional class included in the robotic arm control program, including:

Obtain and inherit at least one functional class contained in the robotic arm control program;

Realize the virtual functions contained in at least one functional class as interfaces, so as to obtain the instantiation pointers corresponding to at least one functional class;

The instantiation pointer corresponding to at least one functional class is passed into the virtual base class as a parameter to obtain the virtual base class after the parameter passing, and the virtual base class after the parameter passing is used as the target plug-in interface corresponding to at least one functional class.

Optionally, based on the target custom program, the instantiation pointer corresponding to the target custom program is obtained, including:

Compile the target custom program into a target library file;

Load the target library file to obtain the instantiation pointer corresponding to the target custom program.

Optionally, load the target library file to obtain the instantiation pointer corresponding to the target custom program, including:

Use the dlopen library function to load the target library file to obtain the instantiation pointer corresponding to the target library file as the instantiation pointer corresponding to the target custom program.

Optionally, run the target customizer based on the instantiation pointer corresponding to the target customizer, including:

Call the initialization interface in the target plug-in interface based on the instantiation pointer corresponding to the target custom program, and initialize the user resource information related to the target library file;

After initialization, call the start interface in the target plug-in interface to run the target custom program.

Optionally, also include:

After the target custom program is running, call the stop interface in the target plug-in interface to uninstall the running target custom program.

Optionally, the initialization interface, the start interface and the stop interface are all non-blocking interfaces.

A control device for a robotic arm, comprising:

The target plug-in interface acquisition module is used to obtain the target plug-in interface corresponding to at least one functional class included in the manipulator control program, and expose the target plug-in interface corresponding to at least one functional class, wherein the target plug-in interface is used to pass at least one functional class The instantiation pointer of the class calls the program of at least one functional class contained in the robotic arm control program, and any functional class in the at least one functional class is used to control the target robotic arm to realize the corresponding function;

The custom information acquisition module is used to obtain the target custom program and/or target library file that meets the user's manipulator control requirements after exposing the target plug-in interface, wherein the library file is a library file compiled based on the target custom program , the target custom program refers to the custom program obtained based on the inherited and implemented target plug-in interface;

A program pointer determination module, configured to obtain an instantiation pointer corresponding to the target custom program based on the target custom program and/or the target library file;

The robotic arm control module is configured to run the target custom program based on the instantiation pointer corresponding to the target custom program, so as to control the target robotic arm.

A mechanical arm control device, including a memory and a processor;

memory for storing programs;

The processor is configured to execute a program to realize each step of any one of the above-mentioned methods for controlling the mechanical arm.

A readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, each step of any one of the above-mentioned methods for controlling a mechanical arm is realized.

It can be known from the above-mentioned technical solutions that the method for controlling the manipulator provided by this application first obtains the target plug-in interface corresponding to at least one functional class included in the manipulator control program, and then obtains the manipulator that meets the user’s manipulator control requirements after exposing the target plug-in interface. The target custom program and/or target library file, and then based on the target custom program and/or target library file, get the instantiation pointer corresponding to the target custom program, and finally run the custom program to control the target robotic arm. This application implements at least one functional class contained in the robot arm control program as a target plug-in interface, so that users can develop a target custom program that meets the requirements of manipulator control based on the target plug-in interface, so that this application can realize the target by running the target custom program. For the control of the target robotic arm, this application does not need to add additional programs to the source code of the robotic arm control program when the user needs to control the target robotic arm according to other functions other than at least one functional class, which avoids the redundancy of the robotic arm control program problem, and this application does not require the user to issue instructions, which reduces the delay in the control of the robotic arm and provides a better user experience.

Description of drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application or the prior art, the following will briefly introduce the drawings that need to be used in the description of the embodiments or the prior art. Obviously, the accompanying drawings in the following description are only It is an embodiment of the present application, and those skilled in the art can also obtain other drawings according to the provided drawings without creative work.

FIG. 1 is a schematic flowchart of a method for controlling a robotic arm provided in an embodiment of the present application;

FIG. 2 is a schematic structural diagram of a robotic arm control device provided in an embodiment of the present application;

Fig. 3 is a block diagram of the hardware structure of the robotic arm control device provided by the embodiment of the present application.

detailed description

The following will clearly and completely describe the technical solutions in the embodiments of the application with reference to the drawings in the embodiments of the application. Apparently, the described embodiments are only some of the embodiments of the application, not all of them. Based on the embodiments in this application, all other embodiments obtained by persons of ordinary skill in the art without making creative efforts belong to the scope of protection of this application.

In view of the problems existing in the prior art, the inventor of the present case conducted in-depth research, and finally proposed a method for controlling the manipulator. Next, the method for controlling the manipulator provided by the present application will be described in detail through the following embodiments.

Please refer to FIG. 1, which shows a schematic flowchart of a method for controlling a manipulator provided in an embodiment of the present application. The method for controlling a manipulator may include:

Step S101. Obtain a target plug-in interface corresponding to at least one functional class included in the robotic arm control program, and expose the target plug-in interface corresponding to at least one functional class.

Among them, the target plug-in interface is used to call the program of at least one function class contained in the robot arm control program through the instantiation pointer of at least one function class, and any function class in the at least one function class is used to control the target robot arm to realize the corresponding function .

Specifically, this embodiment can adjust the robotic arm control program in the prior art according to the functions of each robotic arm contained therein, obtain a robotic arm control program containing at least one functional class, and then obtain the target corresponding to at least one functional class The plug-in interface, and then expose the obtained target plug-in interface, so that the user can call at least one functional class based on the exposed target plug-in interface, so as to write a target custom program that meets the user's robot arm control requirements.

Here, at least one functional class included in the robot arm control program is divided according to the control requirements of the target robot arm, such as forward and reverse solutions, motion control, peripheral IO control, robot state acquisition, robot power on and off, and collaborative robot safety control and other functional divisions. In this step, each functional class is used to control the robotic arm to realize the corresponding function.

In an optional embodiment, the functional classes in this step include the following 6 classes: the first class is an algorithm interface class, for example including: manipulator coordinate system conversion, positive and negative solution, coordinate point conversion of different coordinate systems, etc.; The class is the robot control class, for example, including: startup parameters, tool parameters, joint PID setting, etc.; the third class is the robot IO class, for example, including setting and obtaining the user IO, obtaining the internal IO status of the robot, etc.; the fourth class is the robot motion control class , for example, including robot speed, acceleration, joint motion, linear motion, blend radius, trajectory motion, etc.; the fifth category is robot safety, for example, including reduced mode, collision level, etc.; the sixth category is robot status, for example, including obtaining robot Events, access to robot device information, etc.

Certainly, the above-mentioned 6 categories are only examples, and are not intended to limit the present application.

Step S102, after exposing the target plug-in interface, obtain the target custom program and/or target library file that meet the user's requirements for controlling the manipulator.

Wherein, the library file is a library file compiled based on the target custom program, and the target custom program refers to a custom program obtained based on the inherited and realized target plug-in interface.

Specifically, this application can implement the target plug-in interface, and expose the target plug-in interface as an external interface, so that users can add other function codes according to their needs on the basis of the exposed target plug-in interface, so as to write a program that meets the control requirements of the manipulator. A target customization program for requirements, in which the target plug-in interface can be inherited and implemented, and based on the inherited and implemented target plug-in interface, the user's manipulator control requirements can be realized. Here, the requirement for controlling the robotic arm may be a requirement for controlling the target robotic arm based on at least one of the above functional categories.

Optionally, this step can directly obtain the target custom program written by the user; optionally, the user can compile the written target custom program into a target library file through a PC, then this step can obtain the target library file; optional Yes, this step can also obtain both the target custom program and the target library file.

Step S103: Obtain an instantiation pointer corresponding to the target custom program based on the target custom program and/or the target library file.

Specifically, if the target custom program is obtained in the aforementioned steps, then in this step, the target custom program can be compiled into a target library file, and then the target library file is instantiated to obtain an instantiation pointer corresponding to the target custom program; If the target library file is obtained in the preceding steps, this step can directly instantiate the target library file to obtain an instantiation pointer corresponding to the target custom program.

Step S104, running the target custom program based on the instantiation pointer corresponding to the target custom program, so as to control the target mechanical arm.

The method for controlling the manipulator provided in this application first obtains the target plug-in interface corresponding to at least one functional class included in the manipulator control program, and then obtains the target custom program that meets the user’s manipulator control requirements after exposing the target plug-in interface and/or the target library file, and then based on the target custom program and/or the target library file, obtain the instantiation pointer corresponding to the target custom program, and finally run the custom program based on the instantiation pointer corresponding to the target custom program to target The robotic arm is controlled. This application implements at least one functional class contained in the robot arm control program as a target plug-in interface, so that users can develop a target custom program that meets the requirements of manipulator control based on the target plug-in interface, so that this application can realize the target by running the target custom program. For the control of the target robotic arm, this application does not need to add additional programs to the source code of the robotic arm control program when the user needs to control the target robotic arm according to other functions other than at least one functional class, which avoids the redundancy of the robotic arm control program problem, and this application does not require the user to issue instructions, which reduces the delay in the control of the robotic arm and provides a better user experience.

In an embodiment of the present application, the aforementioned process of "step S101, obtaining the target plug-in interface corresponding to at least one functional class included in the robot control program" is introduced.

Optionally, the process of "step S101, obtaining the target plug-in interface corresponding to at least one functional class contained in the robotic arm control program" may include the following steps:

Step S1011 , acquiring and inheriting at least one function class included in the robotic arm control program.

Step S1012, implementing virtual functions included in at least one functional class as interfaces, so as to obtain instantiation pointers corresponding to at least one functional class.

Specifically, a lot of virtual functions are provided for users in c++, so that at least one functional class can include multiple virtual functions in c++ in each functional class. This step can be performed after inheriting each functional class The virtual functions included in each functional class are realized as interfaces, so as to obtain the instantiation pointers corresponding to at least one functional class. Here, the instantiation pointer corresponding to a function class is used to point to the function class, and by calling the instantiation pointer corresponding to the function class, the function class can be called to perform functional control on the target mechanical arm.

Step S1013, pass the instantiation pointer corresponding to at least one functional class into the virtual base class as a parameter, obtain the virtual base class after passing the parameter, and use the virtual base class after passing the parameter as the target plug-in interface corresponding to at least one functional class .

Here, the virtual base class after parameter passing refers to the virtual base class after passing in the instantiation pointers corresponding to at least one functional class. In this step, the virtual base class after parameter passing can be defined as the "RobotPlugin" class.

Optionally, as described in the aforementioned step S1012, each functional class includes multiple virtual functions, then the target plug-in interface obtained in this step may include multiple functional interfaces corresponding to multiple virtual functions in at least one functional class , for example, the target plug-in interface includes the interface for controlling the axis movement of the target manipulator.

This embodiment re-realizes the external interface by stripping off the control program function of the manipulator, and provides the target plug-in interface externally through the C++ virtual function mode, so that the user can use the target plug-in interface and write the target custom program according to the demand, which improves the user's understanding of the target. The control experience of the robotic arm.

In the following embodiment, the process of "obtaining the instantiation pointer corresponding to the target custom program based on the target custom program" in step S103 will be described.

In this embodiment, the process of "obtaining the instantiation pointer corresponding to the target custom program based on the target custom program" may include:

Step S1031, compiling the target custom program into a target library file.

Step S1032, loading the target library file to obtain the instantiation pointer corresponding to the target custom program.

Optionally, the process of "loading the target library file to obtain the instantiation pointer corresponding to the target custom program" in this step may include: using the dlopen library function to load the target library file to obtain the instantiation pointer corresponding to the target library file, as The instantiation pointer for the target customizer.

In order to load the target custom program during the running of the manipulator control program, the dlopen library function in C language can be used to record the target library file. Here, dlopen can open the specified dynamic link library file in the specified mode and return a handle ( For this step, the handle (that is, the instantiation pointer corresponding to the target custom program) is given to the calling process.

Specifically, in this step, the target library file can be exported into a form recognizable by dlopen using extern "C" in c++, and then loaded with the dlopen library function to obtain the instantiation pointer corresponding to the target library file, which is also The instantiation pointer for the target customizer mentioned in the above steps.

Through the process of this embodiment, the subsequent steps can load and run the target custom program.

In an optional embodiment, the process of "step S104, running the target custom program based on the instantiation pointer corresponding to the target custom program" may include:

Step S1041, calling the initialization interface in the target plug-in interface based on the instantiation pointer corresponding to the target custom program, and initializing the user resource information related to the target library file.

Optionally, the target plug-in interface in this embodiment includes at least an initialization interface and a startup interface, wherein the initialization interface is used to optimize user resource information related to the target library file, and the startup interface is used to run the target custom program after optimization .

In this step, the initialization interface can be accessed through the instantiation pointer corresponding to the target custom program, so as to realize the initialization of user resource information in the target library file.

Step S1042, after initialization, call the startup interface in the target plug-in interface, and run the target custom program.

In this step, the target robotic arm can be controlled by running the target custom program.

If the user controls the robotic arm through jsonrpc data, the user can use these functions after obtaining the instantiation pointers corresponding to at least one functional class in the initialization interface, start the webserver reception in the startup interface, receive the json data and complete the analysis, according to the json The method in the data corresponds to using the instantiated pointer to control the target robotic arm. For example, the method in the json data is moveJoint, and the data is 6 zeros, then you can call the axis interface in the robot motion control class to control the movement of the target robotic arm.

Considering that after the user controls the target robotic arm based on the target custom program, it may not be necessary to control the target robotic arm in the future, or the target robotic arm needs to be controlled according to other requirements. At this time, the running target automatic Define program unloading to avoid resource hogging.

Then, optionally, this embodiment may also include the following step S1043:

Step S1043, after the target custom program runs, call the stop interface in the target plug-in interface to uninstall the running target custom program.

That is, optionally, the target plug-in interface may also include a stop interface, which is used to uninstall the running target custom program. Therefore, in this step, after the target custom program runs, according to the user's uninstallation requirements, Call the stop interface in the target plug-in interface to uninstall the running target custom program.

In a possible implementation, considering that other programs may also be executed when the application is being executed, in order to prevent this embodiment from affecting other For program execution, optionally, the initialization interface, start interface and stop interface are all non-blocking interfaces.

In another possible implementation, the user may have multiple requirements for manipulator control, and thus may write multiple target custom programs. For this reason, this embodiment can also provide a configuration file, which is obtained in step S102. When each target custom program and/or the target library file corresponding to each target custom program, according to the acquisition sequence of the target custom program and/or target library file, configure them in the configuration file in order to adopt the order of the above-mentioned embodiments Run each target custom program; or, according to the user's demand for the control sequence, pre-configure the running sequence of each target custom program in the configuration file, so as to use the above-mentioned embodiments to run each target custom program in the order in the configuration file .

The embodiment of the present application also provides a robotic arm control device. The following describes the robotic arm control device provided in the embodiment of the present application. The robotic arm control device described below and the robotic arm control method described above can be referred to in correspondence.

Please refer to FIG. 2 , which shows a schematic structural diagram of a robotic arm control device provided by an embodiment of the present application. As shown in FIG. 2 , the robotic arm control device may include: a target plug-in interface acquisition module 201, a custom information acquisition module 202, A program pointer determination module 203 and a robot arm control module 204 .

The target plug-in interface acquisition module 201 is used to obtain the target plug-in interface corresponding to at least one functional class included in the manipulator control program, and expose the target plug-in interface corresponding to at least one functional class, wherein the target plug-in interface is used to pass at least one The instantiation pointer of the functional class calls the program of at least one functional class included in the control program of the robotic arm, and any functional class in the at least one functional class is used to control the target mechanical arm to realize the corresponding function.

The custom information acquisition module 202 is configured to obtain a target custom program and/or a target library file that meets the user's robotic arm control requirements after exposing the target plug-in interface, wherein the library file is a library compiled based on the target custom program file, a target customizer is a customizer based on inherited and implemented target plugin interfaces.

The program pointer determining module 203 is configured to obtain an instantiation pointer corresponding to the target custom program based on the target custom program and/or the target library file.

The robotic arm control module 204 is configured to run the target custom program based on the instantiation pointer corresponding to the target custom program, so as to control the target robotic arm.

The robot arm control device provided by this application first obtains the target plug-in interface corresponding to at least one functional class contained in the robot arm control program, and then obtains the target custom program and/or or the target library file, and then based on the target custom program and/or the target library file, obtain the instantiation pointer corresponding to the target custom program, and finally run the custom program based on the instantiation pointer corresponding to the target custom program to target the robot arm Take control. This application implements at least one functional class contained in the robot arm control program as a target plug-in interface, so that users can develop a target custom program that meets the requirements of manipulator control based on the target plug-in interface, so that this application can realize the target by running the target custom program. For the control of the target robotic arm, this application does not need to add additional programs to the source code of the robotic arm control program when the user needs to control the target robotic arm according to other functions other than at least one functional class, which avoids the redundancy of the robotic arm control program problem, and this application does not require the user to issue instructions, which reduces the delay in the control of the robotic arm and provides a better user experience.

In a possible implementation manner, the target plug-in interface acquisition module 201 may include: a function class acquisition inheritance module, a function pointer determination module, and a virtual base class parameter passing module.

The function class acquisition inheritance module is used to acquire and inherit at least one function class included in the robotic arm control program.

The function pointer determination module is used to implement the virtual functions included in at least one function class as interfaces, so as to obtain the instantiation pointers corresponding to the at least one function class respectively.

The virtual base class parameter passing module is used to pass the instantiation pointer corresponding to at least one functional class into the virtual base class as a parameter, and obtain the virtual base class after passing the parameter, and use the virtual base class after passing the parameter as at least one function The class corresponds to the target plugin interface.

In a possible implementation manner, when the program pointer determination module 203 obtains the instantiation pointer corresponding to the target custom program based on the target custom program, it may include: a program compiling module and a library file loading module.

The program compilation module is used for compiling the target custom program into a target library file.

The library file loading module is used to load the target library file to obtain the instantiation pointer corresponding to the target custom program.

In a possible implementation manner, the above-mentioned library file loading module can specifically be used to load the target library file using the dlopen library function, so as to obtain the instantiation pointer corresponding to the target library file as the instantiation pointer corresponding to the target custom program.

In a possible implementation manner, the aforementioned robotic arm control module 204 may include: an initialization interface calling module and a starting interface calling module.

The initialization interface calling module is used to call the initialization interface in the target plug-in interface based on the instantiation pointer corresponding to the target custom program, and initialize the user resource information related to the target library file;

The startup interface calling module is used to call the startup interface in the target plug-in interface after initialization, and run the target custom program.

In a possible implementation manner, the device for controlling a robotic arm provided in the embodiment of the present application may further include: a stop interface calling module.

The stop interface calling module is used to call the stop interface in the target plug-in interface after the target custom program is running, so as to unload the running target custom program.

In a possible implementation manner, the above initialization interface, start interface and stop interface are all non-blocking interfaces.

The embodiment of the present application also provides a device for controlling a robotic arm. Optionally, FIG. 3 shows a block diagram of a hardware structure of the robotic arm control device. Referring to FIG. 3, the hardware structure of the robotic arm control device may include: at least one processor 301, at least one communication interface 302, at least one memory 303 and at least one communication bus 304;

In the embodiment of the present application, the number of processor 301, communication interface 302, memory 303, and communication bus 304 is at least one, and the processor 301, communication interface 302, and memory 303 complete mutual communication through the communication bus 304;

The processor 301 may be a central processing unit CPU, or a specific integrated circuit ASIC (Application Specific Integrated Circuit), or one or more integrated circuits configured to implement the embodiments of the present invention, etc.;

The memory 303 may include a high-speed RAM memory, and may also include a non-volatile memory (non-volatile memory), such as at least one disk memory;

Wherein, the memory 303 stores a program, and the processor 301 can call the program stored in the memory 303, and the program is used for:

Obtain the target plug-in interface corresponding to at least one functional class contained in the robotic arm control program, and expose the target plug-in interface corresponding to at least one functional class, wherein the target plug-in interface is used to call the robotic arm through the instantiation pointer of at least one functional class A program of at least one functional class contained in the control program, any one of the at least one functional class is used to control the target robotic arm to realize the corresponding function;

After exposing the target plug-in interface, obtain the target custom program and/or target library file that meets the user's robotic arm control requirements, where the library file is a library file compiled based on the target custom program, and the target custom program refers to a target custom program based on Inherit and implement the target plugin interface to get custom programs;

Obtain an instantiation pointer corresponding to the target custom program based on the target custom program and/or the target library file;

Run the target custom program based on the instantiation pointer corresponding to the target custom program to control the target robotic arm.

Optionally, the detailed functions and extended functions of the program can refer to the above description.

The embodiment of the present application also provides a readable storage medium on which a computer program is stored, and when the computer program is executed by a processor, the above method for controlling the mechanical arm is implemented.

Optionally, the detailed functions and extended functions of the program can refer to the above description.

Finally, it should also be noted that in this text, relational terms such as and second etc. are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply that these entities or operations Any such actual relationship or order exists between. Furthermore, the term "comprises", "comprises" or any other variation thereof is intended to cover a non-exclusive inclusion such that a process, method, article or apparatus comprising a set of elements includes not only those elements, but also includes elements not expressly listed. other elements of or also include elements inherent in such a process, method, article, or device. Without further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of additional identical elements in the process, method, article or apparatus comprising said element.

Each embodiment in this specification is described in a progressive manner, each embodiment focuses on the difference from other embodiments, and the same and similar parts of each embodiment can be referred to each other.

The above description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the application. Therefore, the present application will not be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims (10)

1. A robot arm control method is characterized by comprising the following steps:

acquiring a target plug-in interface corresponding to at least one function class contained in a mechanical arm control program, and exposing the target plug-in interface corresponding to the at least one function class, wherein the target plug-in interface is used for calling the program of the at least one function class contained in the mechanical arm control program through an instantiation pointer of the at least one function class, and any function class in the at least one function class is used for controlling a target mechanical arm to realize a corresponding function;

after the target plug-in interface is exposed, acquiring a target custom program and/or a target library file meeting the control requirement of a mechanical arm of a user, wherein the library file is compiled based on the target custom program, and the target custom program is a custom program obtained based on the inherited and realized target plug-in interface;

obtaining an instantiation pointer corresponding to the target self-defining program based on the target self-defining program and/or the target library file;

and operating the target self-defining program based on the instantiation pointer corresponding to the target self-defining program so as to control the target mechanical arm.

2. The method according to claim 1, wherein the obtaining of the target plug-in interface corresponding to at least one function class included in the robot control program comprises:

acquiring and inheriting at least one function class contained in the mechanical arm control program;

the virtual functions respectively contained in the at least one function class are realized as interfaces to obtain instantiation pointers respectively corresponding to the at least one function class;

and transmitting instantiation pointers corresponding to the at least one function class into a virtual base class as parameters to obtain a reference-transmitted virtual base class, and using the reference-transmitted virtual base class as a target plug-in interface corresponding to the at least one function class.

3. The mechanical arm control method of claim 1, wherein obtaining an instantiation pointer corresponding to the target custom program based on the target custom program comprises:

compiling the target custom program into the target library file;

and loading the target library file to obtain an instantiation pointer corresponding to the target self-defined program.

4. The method as claimed in claim 3, wherein the loading the target library file to obtain an instantiation pointer corresponding to the target custom program comprises:

and loading the target library file by using a dlopen library function to obtain an instantiation pointer corresponding to the target library file, wherein the instantiation pointer is used as the instantiation pointer corresponding to the target self-defined program.

5. The method for controlling a robot arm according to claim 1, wherein the running the target custom program based on the instantiation pointer corresponding to the target custom program comprises:

calling an initialization interface in the target plug-in interface based on an instantiation pointer corresponding to the target custom program, and initializing user resource information related to the target library file;

and after initialization, calling a starting interface in the target plug-in interface, and running the target custom program.

6. The robot arm control method according to claim 5, further comprising:

and after the target custom program runs, calling a stop interface in the target plug-in interface, and unloading the running target custom program.

7. The method of claim 6, wherein the initialization interface, the start interface, and the stop interface are non-blocking interfaces.

8. A robot arm control apparatus, comprising:

the system comprises a target plug-in interface acquisition module, a target plug-in interface acquisition module and a target plug-in interface acquisition module, wherein the target plug-in interface acquisition module is used for acquiring a target plug-in interface corresponding to at least one function class contained in a mechanical arm control program and exposing the target plug-in interface corresponding to the at least one function class, the target plug-in interface is used for calling the program of the at least one function class contained in the mechanical arm control program through an instantiation pointer of the at least one function class, and any one function class in the at least one function class is used for controlling a target mechanical arm to realize a corresponding function;

the user-defined information acquisition module is used for acquiring a target user-defined program and/or a target library file meeting the control requirement of the mechanical arm of a user after the target plug-in interface is exposed, wherein the library file is compiled based on the target user-defined program, and the target user-defined program is a user-defined program obtained based on the inherited and realized target plug-in interface;

the program pointer determining module is used for obtaining an instantiation pointer corresponding to the target self-defining program based on the target self-defining program and/or the target library file;

and the mechanical arm control module is used for operating the target self-defining program based on the instantiation pointer corresponding to the target self-defining program so as to control the target mechanical arm.

9. A robot arm control apparatus characterized by comprising a memory and a processor;

the memory is used for storing programs;

the processor is configured to execute the program to implement the steps of the robot arm control method according to any one of claims 1 to 7.

10. A readable storage medium having stored thereon a computer program for implementing the steps of the robot arm control method according to any of claims 1-7 when executed by a processor.

Images