1. A method for realizing an SOMEIP communication middle layer based on an SOA architecture of a vehicle-mounted Android system is characterized by comprising the following steps:

compiling a SOMEIP C + + library by using an Android NDK tool;

calling the SOMEIP library function through the JNI interface, and packaging into system service;

utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner to generate a ServiceManager class;

establishing an SOA service interface template file, and storing the basic service information of the SOMEIP service input by a user;

reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file;

and adding the generated java code file into an Android project, and packaging the java code file with other java code files to generate an SDK package for the application layer.

2. The method according to claim 1, wherein compiling the SOMEIP C + + library using the Android NDK tool comprises:

adding the SOMEIP C + + library into CMakeLists files compiled by Android engineering, compiling the SOMEIPC + + library by using CMake and NDK to generate so files with different CPU architectures, packaging universal functions of the SOMEIP library and generating a JNI interface.

3. The method according to claim 2, wherein the calling SOMEIP library functions through JNI interface and encapsulating into system service comprises:

based on a Service component of an Android system, a system level Service (SOMEIP Service) is created, an SOMEIP library is called through a JNI (just noticeable interface) interface, and the system level Service (SOMEIP Service) is started along with the system startup.

4. The method according to claim 3, wherein the cross-process calling the SOMEIP Service by using the Android AIDL generates a ServiceManager class, and the method comprises the following steps:

and accessing a system level Service (SOMEIP Service) by using the Android AIDL in a cross-process manner, calling an SOMEIP interface, and creating a base class of SOA Service proxy/skeletton.

5. The method of claim 4, wherein the formulating a SOA service interface template file for storing the basic service information of the SOMEIP service input by the user comprises:

creating an SOA service interface template file, wherein the SOA service interface template file comprises service basic information, the service basic information comprises a service name, a service ID and service interface information, the service interface information comprises a method interface type, a method interface name, a method interface ID, a method interface parameter and a method affiliated event group ID, the method interface parameter is an input/output parameter and a parameter type of a method interface, and the SOA service interface template file is an Excel form or an xml file;

and receiving basic service information and communication configuration information input into the SOA service interface template file by a user, wherein the communication configuration information comprises a protocol IP address and a communication port required by SOMEIP communication.

6. The method of claim 5, wherein the reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into the SOMEIP communication middle layer code template file, and generating a java code file comprises:

compiling a python script, reading basic service information of a user in the SOA service interface template file through the python script, and generating json character string data;

and inputting the generated json character string data into a pre-established SOMEIP communication middle layer code template file to generate a communication middle layer proxy/skeeleton code file, wherein the SOMEIP communication middle layer code template file has all implementation flows of the method/event/field method interface defined by SOMEIP and conforms to AUTOSAR architecture specification.

7. The method as claimed in claim 1 or 6, wherein the SOMEIP communication middle layer code template file is jinja2 code template file.

8. A SOMEIP communication intermediate layer implementation system based on a vehicle-mounted Android system SOA architecture is characterized by comprising the following steps:

the compiling module is used for compiling the SOMEIP C + + library by using an Android NDK tool;

the encapsulation module is used for calling the SOMEIP library function through the JNI interface and encapsulating the SOMEIP library function into system service;

the calling module is used for calling the SOMEIP Service by utilizing the Android AIDL cross-process to generate a ServiceManager class;

the storage module is used for formulating an SOA service interface template file and storing the basic service information of the SOMEIP service input by the user;

the generating module is used for reading the basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file and generating a java code file;

and the packaging module is used for adding the generated java code file into the Android project, and packaging the java code file with other java code files to generate an SDK (software development kit) package for use by the application layer.

9. An electronic device, comprising a memory and a processor, wherein the processor is configured to implement the steps of the method for implementing the SOMEIP communication middle layer based on the SOMEIP of the vehicle-mounted Android system SOA architecture according to any one of claims 1 to 7 when executing the computer management class program stored in the memory.

10. A computer-readable storage medium, on which a computer management class program is stored, and the computer management class program, when executed by a processor, implements the steps of the implementation method for the on-vehicle Android system SOA architecture SOMEIP communication middle layer based on claim 1-7.

Background

In the field of intelligent driving, an automobile IVI system (vehicle-mounted entertainment information system) is an intelligent multimedia device integrated in an automobile console, and more manufacturers adopt an Android system to design the IVI system, so that the implementation of an SOMEIP communication intermediate layer based on an SOA (service oriented) software architecture of the Android system is a very important step in the field of intelligent driving.

With the rapid development of automobile intellectualization, the SOMEIP protocol is largely used in the vehicle-mounted ECU device for data communication of the vehicle-mounted ethernet, and the communication between the IVI system designed based on the Android system and the vehicle-mounted ECU must also adopt the SOMEIP protocol. The existing SOMEIP communication intermediate layer codes are realized by using a C + + language with a Linux system as a platform and cannot be used on the Android system.

On an Android system, a service-oriented architecture is taken as a design concept, an Android system API is combined to realize an SOMEIP communication intermediate layer, and meanwhile, the design of a service interface must meet AUTOSAR architecture specification, which is a problem to be solved.

Disclosure of Invention

Aiming at the technical problems in the prior art, the invention provides a method and a system for realizing an SOMEIP communication intermediate layer based on a vehicle-mounted Android system SOA architecture.

According to a first aspect of the invention, a method for realizing an SOMEIP communication middle layer based on an SOA architecture of a vehicle-mounted Android system is provided, which comprises the following steps: compiling a SOMEIP C + + library by using an Android NDK tool; calling the SOMEIP library function through the JNI interface, and packaging into system service; utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner to generate a ServiceManager class; establishing an SOA service interface template file, and storing the basic service information of the SOMEIP service input by a user; reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file; and adding the generated java code file into an Android project, and packaging the java code file with other java code files to generate an SDK package for the application layer.

On the basis of the technical scheme, the invention can be improved as follows.

Optionally, the compiling a SOMEIP C + + library by using an Android NDK tool includes:

adding the SOMEIP C + + library into CMakeLists files compiled by Android engineering, compiling the SOMEIPC + + library by using CMake and NDK to generate so files with different CPU architectures, packaging universal functions of the SOMEIP library and generating a JNI interface.

Optionally, the calling the SOMEIP library function through the JNI interface and encapsulating the SOMEIP library function into a system service includes: based on a Service component of an Android system, a system level Service (SOMEIP Service) is created, an SOMEIP library is called through a JNI (just noticeable interface) interface, and the system level Service (SOMEIP Service) is started along with the system startup.

Optionally, the cross-process calling the Service by using the Android aid dl to generate a Service manager class includes: and accessing a system level Service (SOMEIP Service) by using the Android AIDL in a cross-process manner, calling an SOMEIP interface, and creating a base class of SOA Service proxy/skeletton.

Optionally, the formulating an SOA service interface template file and storing the basic service information of the SOMEIP service input by the user includes: creating an SOA service interface template file, wherein the SOA service interface template file comprises service basic information, the service basic information comprises a service name, a service ID and service interface information, the service interface information comprises a method interface type, a method interface name, a method interface ID, a method interface parameter and a method affiliated event group ID, the method interface parameter is an input/output parameter and a parameter type of a method interface, and the SOA service interface template file is an Excel form or an xml file; and receiving basic service information and communication configuration information input into the SOA service interface template file by a user, wherein the communication configuration information comprises a protocol IP address and a communication port required by SOMEIP communication.

Optionally, the reading, by using a python script, basic service information of the service in the SOA service interface template file, inputting the basic service information into the SOMEIP communication intermediate layer code template file, and generating a java code file includes: compiling a python script, reading basic service information of a user in the SOA service interface template file through the python script, and generating json character string data; and inputting the generated json character string data into a pre-established SOMEIP communication middle layer code template file to generate a communication middle layer proxy/skeeleton code file, wherein the SOMEIP communication middle layer code template file has all implementation flows of the method/event/field method interface defined by SOMEIP and conforms to AUTOSAR architecture specification.

Optionally, the SOMEIP communication intermediate layer code template file is a jinja2 code template file.

According to a second aspect of the present invention, there is provided a system for implementing an SOMEIP communication intermediate layer based on a vehicle-mounted Android system SOA architecture, including: the compiling module is used for compiling the SOMEIP C + + library by using an Android NDK tool; the encapsulation module is used for calling the SOMEIP library function through the JNI interface and encapsulating the SOMEIP library function into system service; the calling module is used for calling the SOMEIP Service by utilizing the Android AIDL cross-process to generate a ServiceManager class; the storage module is used for formulating an SOA service interface template file and storing the basic service information of the SOMEIP service input by the user; the generating module is used for reading the basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file and generating a java code file; and the packaging module is used for adding the generated java code file into the Android project, and packaging the java code file with other java code files to generate an SDK (software development kit) package for use by the application layer.

According to a third aspect of the present invention, an electronic device is provided, which includes a memory and a processor, where the processor is configured to implement the method for implementing the SOMEIP communication intermediate layer based on the SOA architecture of the vehicle-mounted Android system when executing a computer management class program stored in the memory.

According to a fourth aspect of the present invention, a computer-readable storage medium is provided, on which a computer management class program is stored, and the computer management class program, when executed by a processor, implements the steps of the method for implementing the SOMEIP communication middle layer based on the SOA architecture of the vehicle-mounted Android system.

The invention provides a method and a system for realizing an SOMEIP communication intermediate layer based on an SOA architecture of a vehicle-mounted Android system, which are characterized in that an SOMEIP C + + library is compiled by utilizing an Android NDK tool; calling the SOMEIP library function through the JNI interface, and packaging into system service; utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner; reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file; adding the java code files into an Android project, packaging the java code files into an SDK program packaging application layer for use, on an Android system, realizing an SOMEIP communication intermediate layer by taking a service-oriented architecture as a design concept and combining an Android system API, and simultaneously, designing a service interface to meet AUTOSAR architecture specification.

Drawings

FIG. 1 is a flow chart of a method for implementing an SOMEIP communication intermediate layer based on an SOA architecture of a vehicle-mounted Android system;

FIG. 2 is a schematic structural diagram of an SOMEIP communication intermediate layer implementation system based on a vehicle-mounted Android system SOA architecture;

FIG. 3 is a schematic diagram of a hardware structure of a possible electronic device provided in the present invention;

fig. 4 is a schematic diagram of a hardware structure of a possible computer-readable storage medium according to the present invention.

Detailed Description

The following detailed description of embodiments of the present invention is provided in connection with the accompanying drawings and examples. The following examples are intended to illustrate the invention but are not intended to limit the scope of the invention.

Fig. 1 is a flowchart of a method for implementing an SOMEIP communication intermediate layer based on an SOA architecture of a vehicle-mounted Android system, as shown in fig. 1, the method includes: 101. compiling a SOMEIP C + + library by using an Android NDK tool; 102. calling the SOMEIP library function through the JNI interface, and packaging into system service; 103. utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner to generate a ServiceManager class; 104. establishing an SOA service interface template file, and storing the basic service information of the SOMEIP service input by a user; 105. reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file; 106. and adding the generated java code file into an Android project, and packaging the java code file with other java code files to generate an SDK package for the application layer.

It can be understood that based on the defects and requirements in the background art, the invention provides a method for realizing the SOMEIP communication middle layer code by combining the API of the Android system based on the java language.

During specific implementation, an Android NDK tool is used for compiling a SOMEIP C + + library; calling the SOMEIP library function through the JNI interface, and packaging into system service; utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner; reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file; and adding the java code file into the Android project, and packaging the java code file into an SDK program packaging application layer for use, thereby ending the scheme.

On the Android system, a service-oriented architecture is taken as a design concept, an Android system API is combined, an SOMEIP communication intermediate layer is realized, and meanwhile, the design of a service interface conforms to AUTOSAR architecture specification; the problem of realizing the SOMEIP communication intermediate layer of the Android platform is solved, meanwhile, the code architecture accords with AUTOSAR standards, the code file is generated by utilizing the template, the development efficiency is greatly improved, the reusability is high, and the maintainability is good.

In a possible embodiment, compiling a SOMEIP C + + library using an Android NDK tool specifically includes: adding the SOMEIP C + + library to a CMakeLists file compiled in an Android project, compiling the SOMEIP library by using CMake and NDK, generating so files of different CPU architectures such as arm, x86 and the like, packaging universal functions of the SOMEIP library, and generating a java local interface (JNI) for upper-layer calling.

In a possible embodiment mode, the method calls the SOMEIP library function through the JNI interface and encapsulates the SOMEIP library function into a system service, and comprises the following steps: based on a Service component of an Android system, a system level Service (SOMEIP Service) is created, an SOMEIP library is called through a JNI (just noticeable interface) interface, and the system level Service (SOMEIP Service) is started along with the system startup.

It can be understood that after a java native interface (JNI interface) is generated, a system level Service (SOMEIP Service) is created based on a Service component which is one of four major Android components, and the Service is started along with the system startup by calling a SOMEIP library through the JNI interface. In the vehicle-mounted system, the security is most important, and the system-level service has the advantages of high authority and incapability of data communication due to the fact that processes are not killed by the system.

In a possible embodiment, the method for generating the ServiceManager class by using the Android aid dl cross-process call Service includes: and accessing a system level Service (SOMEIP Service) by using the Android AIDL in a cross-process manner, calling an SOMEIP interface, and creating a base class of SOA Service proxy/skeletton.

It can be understood that after the system level Service is generated, Android engineering is performed, a ServiceManager class is created, an Android aid dl (Android Interface Definition Language) is used to cross-process access the system level Service, an SOMEIP Interface is called, and a base class of SOA Service proxy/skelleton is created.

In a possible embodiment mode, using Android aid/Definition Language (Android Interface Definition Language) to access a system level Service (SOMEIP) Service across processes, creating a base class of an SOA Service proxy/skexeton, and creating an SOA Service Interface template file, specifically, creating the SOA Service Interface template file, wherein the SOA Service Interface template file includes Service basic information, the Service basic information includes a Service name, a Service ID and Service Interface information, the Service Interface information includes a method Interface type, a method Interface name, a method Interface ID, a method Interface parameter and a method event group ID, the method Interface parameter is description information such as an input/output parameter and a parameter type of a method Interface, and the SOA Service Interface template file is an Excel table or an xml file.

After the SOA service interface template file is created, a user can input basic service information and communication configuration information through the SOA service interface template file, wherein the communication configuration information comprises a protocol IP address and a communication port required by SOMEIP communication, and the protocol required by the SOMEIP communication is mainly UDP/TCP.

In a possible embodiment, the reading, by using a python script, the basic service information of the service in the SOA service interface template file, inputting the basic service information into the service communication intermediate layer code template file, and generating a java code file includes: compiling a python script, reading basic service information in an SOA service interface template file from a user through the python script, and generating json character string data; and inputting the generated json character string data into a pre-established SOMEIP communication middle layer code template file to generate a proxy/skeletton communication middle layer code file. All implementation flows of three types of method interfaces of method/event/field defined by the SOMEIP are arranged in the SOMEIP communication middle layer code template file, and the flow designs of creating, searching for service, request/response, subscribing event and the like of the service all conform to AUTOSAR architecture specification.

It should be noted that through the two steps 104 and 105, the user only needs to input the service information and the service interface information according to the Excel form or the xml template, and then can automatically generate all java code files of the SOMEIP service through the jinja2 code template without handwriting a large number of service repeated codes, so that the development efficiency is improved.

And finally, adding the generated service proxy/skeeleton code file into an Android project, and packaging the service proxy/skeeleton code file with other java code files to generate an SDK for an application layer to use, thereby completing the realization of the SOMEIP communication middle layer code on the Android system.

The method for realizing the SOMEIP communication intermediate layer of the SOA architecture of the vehicle-mounted Android system provided by the invention is integrally described as follows, and mainly comprises the following steps:

(1) the SOMEIP communication protocol is realized based on C + + language, then an Android NDK tool is used for compiling SOMEIP C + + codes, so that so-library files of arm, x86 and other different CPU architectures are generated, the so-library files are added into Android projects, and universal functions of the SOMEIP libraries are packaged to generate java local interfaces (JNI) for upper-layer calling.

(2) The service of one of the four Android components is used, the SOMEIP library function is called through the JNI, the service authority is improved to serve the system, and the system is started along with the starting of the system.

(3) Based on an Android IPC mechanism, cross-process calling of the SOMEIP Service is performed through an Android AIDL, and a ServiceManager class is generated.

(4) And receiving and storing service information of the SOMEIP service, interface information of the corresponding service and communication configuration information input by a user by using a pre-specified Excel form or an xml template file.

(5) Reading a table or an xml file for storing data such as service information and the like by a code generation script written by a python language to generate json format data, inputting the data into a prefabricated SOMEIP communication intermediate layer code template to generate a java code file, wherein the SOMEIP communication intermediate layer template has all implementation processes of the service method interface.

(6) And adding the generated java code file of the service interface into an Android project, and packaging to generate an SDK file of an Android SOMEIP communication middle layer for application layer integration, so far, ending the scheme.

Fig. 2 is a system structure diagram for implementing the SOMEIP communication intermediate layer based on the vehicle-mounted Android system SOA architecture, and as shown in fig. 2, the system for implementing the SOMEIP communication intermediate layer based on the vehicle-mounted Android system SOA architecture includes a compiling module 201, a packaging module 202, a calling module 203, a storing module 204, a generating module 205, and a packaging module 206, where:

a compiling module 201, configured to compile a SOMEIP C + + library using an Android NDK tool; the encapsulating module 202 is used for calling the SOMEIP library function through the JNI interface and encapsulating the SOMEIP library function into system service; the calling module 203 is used for calling the SOMEIP Service by using the Android AIDL in a cross-process manner to generate a ServiceManager class; the storage module 204 is used for formulating an SOA service interface template file and storing the basic service information of the SOMEIP service input by the user; the generating module 205 is configured to read basic service information of the SOMEIP service in the SOA service interface template file by using a python script, input the basic service information into an SOMEIP communication intermediate layer code template file, and generate a java code file; and the packaging module 206 is used for adding the generated java code file into the Android project, and packaging the java code file with other java code files to generate an SDK package for the application layer.

It can be understood that the implementation system of the vehicle-mounted Android system SOA architecture SOMEIP communication intermediate layer provided by the invention corresponds to the implementation method of the vehicle-mounted Android system SOMEIP communication intermediate layer provided by each embodiment, and the related technical features of the implementation system of the vehicle-mounted Android system SOMEIP communication intermediate layer can refer to the related technical features of the implementation method of the vehicle-mounted Android system SOA architecture SOMEIP communication intermediate layer, and are not described herein again.

Referring to fig. 3, fig. 3 is a schematic diagram of an embodiment of an electronic device according to an embodiment of the invention. As shown in fig. 3, an embodiment of the present invention provides an electronic device 300, which includes a memory 310, a processor 320, and a computer program 311 stored in the memory 310 and executable on the processor 320, wherein the processor 320 executes the computer program 1311 to implement the following steps: compiling a SOMEIP C + + library by using an Android NDK tool; calling the SOMEIP library function through the JNI interface, and packaging into system service; utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner to generate a ServiceManager class; establishing an SOA service interface template file, and storing the basic service information of the SOMEIP service input by a user; reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file; and adding the generated java code file into an Android project, and packaging the java code file with other java code files to generate an SDK package for the application layer.

Referring to fig. 4, fig. 4 is a schematic diagram of an embodiment of a computer-readable storage medium according to the present invention. As shown in fig. 4, the present embodiment provides a computer-readable storage medium 400, on which a computer program 411 is stored, the computer program 411 implementing the following steps when executed by a processor: compiling a SOMEIP C + + library by using an Android NDK tool; calling the SOMEIP library function through the JNI interface, and packaging into system service; utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner to generate a ServiceManager class; establishing an SOA service interface template file, and storing the basic service information of the SOMEIP service input by a user; reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file; and adding the generated java code file into an Android project, and packaging the java code file with other java code files to generate an SDK package for the application layer.

According to the method and the system for realizing the SOMEIP communication intermediate layer based on the SOA architecture of the vehicle-mounted Android system, the SOMEIP C + + library is compiled by using an Android NDK tool; calling the SOMEIP library function through the JNI interface, and packaging into system service; utilizing the Android AIDL to call the SOMEIP Service in a cross-process manner; reading basic service information of the SOMEIP service in the SOA service interface template file by using a python script, inputting the basic service information into an SOMEIP communication intermediate layer code template file, and generating a java code file; the method comprises the steps of adding java code files into an Android project, packaging the java code files into an SDK program packaging application layer for use, realizing an SOMEIP communication intermediate layer on an Android system by taking a service-oriented architecture as a design concept and combining an Android system API (application program interface), enabling the design of a service interface to conform to the AUTOSAR architecture specification, solving the problem of realization of the SOMEIP communication intermediate layer of an Android platform, enabling the code architecture to conform to the AUTOSAR specification, and generating the code files by utilizing a template, so that the development efficiency is greatly improved, the reusability is high, and the maintainability is good.

It should be noted that, in the foregoing embodiments, the descriptions of the respective embodiments have respective emphasis, and reference may be made to relevant descriptions of other embodiments for parts that are not described in detail in a certain embodiment.

As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, and the like) having computer-usable program code embodied therein.

The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

While preferred embodiments of the present invention have been described, additional variations and modifications in those embodiments may occur to those skilled in the art once they learn of the basic inventive concepts. Therefore, it is intended that the appended claims be interpreted as including preferred embodiments and all such alterations and modifications as fall within the scope of the invention.

It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is also intended to include such modifications and variations.