2. voraus.core
Fig. 1 The voraus.core software stack
With the voraus.core manufacturers, integrators and end users can easily create and execute solutions for all applications and optimize their entire automation. Operate effortlessly with a no-code interface and virtually no restrictions.
The voraus.core is the middleware that enables building a modern automation stack. Through its open API (OPC UA and Python) it ensures flexible expansion of devices and functionality from to driver level to the top interface level. The latter allows the voraus.core to be connected to higher-level platforms such as graphical user interfaces like the voraus.operator, ERP or cloud services.
This unique, hardware agnostic platform facilitates modern software development, testing and deployment and fast software update cycles. The voraus.core provides all the necessary resources to future-proof your automation solution with a high level of efficiency.
Benefits
- Universal
No vendor-lock
Orchestrates your complete automation cell
Supports various robot types, from cobots to industrial robots
Seamless and rapid integration of peripherals such as grippers and cameras
- Flexible
Shipped with the voraus.operator it features a user-friendly, graphical interface
Our Python API allows programming of complex automation tasks
Hardware agnostic – the voraus.core runs on a variety of computing platforms
- Productive
Reduces the cost of implementing applications by 45 % and accelerates the process by 85 %
Decreases integration costs up to 80 %
Ensures 100 % independence, allowing users to accomplish everything themselves
Functionality
The voraus.core, regardless of its configuration, is equipped as standard with the preconfigured modules for controlling your automation system.
Layer |
Functionality |
|---|---|
Runtime |
The runtime is the base layer of the voraus.core – the middleware for building a modern software stack for industrial automation. It provides interfaces to customize automation system control from interface down to driver level. The runtime allows the deployment and execution of encrypted and licensable software components (License Handling). It provides error management and logging to make the orchestration of multiple services easy. Additionally, it offers features for managing software deployment, backup, restoration, and updates; empowering users to keep control over their systems (core services). If required, the runtime is delivered with a real-time operating system.
The runtime is the basis to deploy driver and build a modern automation stack. In most scenarios the runtime will be combined with either a robot or a fieldbus driver, or multiple robots and fieldbus drivers, and much more.
|
Driver |
Various drivers for robots and peripherals are supported and delivered as voraus.core bundles, for instance In addition, an API is provided for developing your own drivers. Core functionalities:
|
Application |
Your application is implemented at this level including control of your automation cell or the query of services connected via the interface layer. The implementation is carried out in the modern programming language Python and against the open API. |
Interfaces |
The interface layer allows for connecting your smart services or graphical user interfaces for no-code programming. One solution is provided with the voraus.core – the voraus.operator which has the following features:
|