Documentation

helyOS^® core
 

The helyOS^® core is composed of a Postgres database and a NodeJs server that works as a ready-to-use backend for applications in yard automation. It is the main component of the framework, enclosing the business logics and the orchestration of services and assignments. The helyOS^® core has six responsibilities:

1. Automated configuration of the RabbitMQ server to be used as message broker.
2. Authenticate applications that connect to the yard automation.
3. Collection of the yard data (obstacles, map, agent ids and positions, etc.).
4. Provision of an API endpoint for external applications for creating missions, sending messages to the agent and accessing the yard data.
5. Orchestration of mission assignments that are sent to the agents via RabbitMQ. It is important to stress that the »orchestration« includes the reservation/release of agents, and the ordered dispatch of assignments to each agent.
6. Orchestration of microservices used to calculate the assignment data.

The helyOS^® core transmits and receives messages from agents via a RabbitMQ server. The configuration of the RabbitMQ server is automatically done by the helyOS^® core, including the registration of new agents. The RabbitMQ server is responsible for the authentication of the connected agents.

Microservices

The word »microservice« refers to »microservice architecture«. In the microservice approach, the software functionalities are implemented using small and independent services. This maximizes the decoupling and facilitates the development according to specific domains.

The advantages of using a microservice architecture are various:

Scalability: Microservices enable horizontal scaling, meaning each service can be scaled independently based on its specific requirements.

Modularity and Maintainability: Since each microservice focuses on a specific business capability, the system becomes modular and easier to maintain.

Fault Isolation: By dividing the system into smaller, independent services, failures or issues in one service are isolated and do not affect the entire system.

Technology Heterogeneity: Microservices allow the use of different technologies and programming languages for different services. This enables selection of the most appropriate tools and technologies for each specific task or service, rather than being limited to a single technology stack.

Enhanced Team Autonomy: Each microservice can be developed and maintained by a separate team, allowing for smaller, specialized teams within an organization.

Easy integration: Microservices communicate with each other using well-defined APIs, making it easier to integrate them with other services or third-party systems. This facilitates innovation, interoperability, and the ability to leverage external services.

External applications
 

The external applications represent any application or module that interacts with helyOS^® core using HTTP and web socket protocol. The communication uses GraphQL API which empowers developers with complete control over application data. This means that developers can effortlessly interface with and manipulate data to meet the precise needs of their applications.

They can query helyOS^®’ database, request or cancel missions, manage agents, resources and map information.

The external applications can be a user interface software or headless interfaces to larger managing or logistic systems.

Learn more: https://helyos-manual.readthedocs.io/en/latest/3-helyos-and-client-apps/application-accounts.html

JavaScript-SDK
 

A special category of external applications are web apps, which are usually written in JavaScript. To accelerate their development, front-end programmers can use our JavaScript-SDK, the helyosjs_sdk, which wraps the most common GraphQL commands in convenient TypeScript model classes and CRUD functions (create, read, update, delete).  

Install:

$ npm i helyosjs-sdk  --save

Source code: https://github.com/helyOSFramework/helyos-javascript-sdk

Documentation: https://github.com/helyOSFramework/helyos-javascript-sdk

Agents (vehicles and sensors)
 

The helyOS^® framework has a broad concept of agents. In principle, agents are any device or software module that communicates with helyOS^® core via RabbitMQ using MQTT or AMQP protocol.

They can be sensors that simply push data, or entities that receive assignments and commands, such as vehicles, cameras, traffic lights, etc. Another important category of agents are the smart control units, software modules that can request missions or issue commands supporting other agents in the execution of their assignments. 

Learn more: https://helyos-manual.readthedocs.io/en/latest/5-communication-between-helyos-and-agents/5-index.html

Agent-SDK
 

The python package helyos-agent-sdk encloses methods and data structures definitions that facilitate the connection to helyOS^® core through RabbitMQ.

List of features

• RabbitMQ client to communicate with helyOS^®.
• AMQP and MQTT Protocol.
• SSL connection
• Agent and assignment status definitions.
• Easy access to helyOS^® assignments via callbacks.
• Application-level encryption.

Install:

pip install helyos_agent_sdk

Source Code: https://github.com/helyOSFramework/helyos_agent_sdk

Documentation: https://helyosframework.github.io/helyos_agent_sdk/build/html/index.html

ROS wrapper
 

The python package helyos_agent_ros_wrapper implements an interface to the package helyos_agent_sdk that facilitates the integration of ROS agents.

The ROS wrapper, in conjunction with the helyos_agent_sdk package, enables seamless connection and interaction between ROS and RabbitMQ message broker. It effectively links the ROS topic channels to the appropriate RabbitMQ routings, as defined by helyOS.

Example of usage:

rosrun helyos_agent_ros_wrapper helyos_agent_ros_wrapper [param_name]:=[new_value]