At Avancio, we lead technological advancements, revolutionizing industries through expert-driven innovation. Our team thrives on solving complex challenges, making impactful changes across sectors like automotive, retail, and telecom.

We are always on the lookout for talented individuals with experience in the following areas:

ADAS/AD, Autonomous Navigation, Driver Monitoring Systems, or Vehicle-to-Everything (V2X) Communication.

Advanced Connectivity technologies, including 5G, Edge Networking, and IoT Connectivity.

AI/ML expertise in areas such as Computer Vision, Natural Language Processing (NLP), Predictive Analytics, and Reinforcement Learning.

Cloud and Edge Computing, with a focus on Cloud Migration, Cloud Security, or Platform as a Service (PaaS).

Cybersecurity, including Threat Detection and Response, Network Security, and Data Protection Compliance.

Future Mobility solutions, such as Connected Car Systems, Electric Vehicles (EV) technology, or Smart Traffic Management.

Experience in Industrializing Machine Learning, including Automated ML (AutoML), Model Deployment, and Scalable ML Pipelines.

Process Virtualization through Augmented Reality (AR), Digital Twins, and Workflow Automation.

Robotics and Industrial IoT, with a focus on Automation Solutions, IoT Device Management, and Predictive Maintenance.

Take on challenging and impactful projects that drive the future of tech.

Enjoy endless opportunities for learning and career progression.

Collaborate with a talented and passionate team of industry experts.

Benefit from a highly competitive salary and an exceptional benefits package.

Experience the freedom of flexible working hours within a supportive and dynamic work culture.

Access comprehensive health benefits and wellness programs designed with your well-being in mind.

Join us at Avancio to make a significant impact in the technology sector. If you're passionate about pushing boundaries and driving tech excellence, we invite you to become part of our dynamic team.

Open Application

The resource you're looking for isn't here—let's get you back on track.

This code leads nowhere

This article presents a method for utilizing Large Language Models (LLMs) to query a Neo4j graph constructed from the 

International Consortium of Investigative Journalists Offshore Leaks Database

, aiming to gain insights and identify potential cases of money laundering.

Knowledge Graphs are structured representations of information that capture entities and their relationships. They are designed to integrate and organize vast amounts of data into a format that is both human-readable and machine-interpretable. By connecting related pieces of information, Knowledge Graphs facilitate more sophisticated querying, analytics, and inference, enabling the discovery of new insights and relationships within the data.

Knowledge Graphs connect disparate data points, providing a holistic view of information. This connectivity makes it easier to uncover hidden relationships and patterns that might not be evident from isolated data points.

They facilitate the integration of data from various sources, breaking down data silos and ensuring that all relevant information is linked and accessible.

With Knowledge Graphs, users can perform complex queries that traverse multiple layers of data relationships, offering more precise and insightful answers than traditional databases.

By representing entities and their relationships, Knowledge Graphs provide context to data, enhancing the understanding and interpretability of the information.

Knowledge Graphs serve as a rich source of structured data that can be leveraged by AI and machine learning models for tasks such as natural language understanding, recommendation systems, and predictive analytics.

Neo4j is a leading graph database management system designed to store, query, and manage large-scale graph data. Unlike traditional relational databases that use tables to represent data, Neo4j uses graph structures with nodes, edges, and properties to represent and store data. This graph-based approach makes Neo4j highly efficient for managing and querying complex data relationships.

Uses nodes to represent entities and relationships (edges) to connect them.

Efficiently handles large volumes of connected data.

Easily adapts to evolving data structures without requiring extensive schema modifications.

Optimized for graph traversals, offering fast query execution for complex relationship queries.

Cypher is a powerful query language designed specifically for working with graph data in Neo4j. It provides a simple and expressive syntax for querying and updating graph structures, allowing users to easily specify patterns of nodes and relationships to be matched or created within the graph.

Leveraging Large Language Models (LLMs) for Knowledge Graphs

With advancements in AI and natural language processing, Large Language Models (LLMs) like GPT-4 have become powerful tools for generating text and understanding context. By leveraging LLMs, we can automate the generation of Cypher statements, simplifying the process of handling Knowledge Graphs in Neo4j. This integration allows us to harness the strengths of AI to enhance data connectivity, query capabilities, and overall knowledge management.

In the following sections, we will explore how to use LLMs to generate Cypher statements for querying a Knowledge Graph in Neo4j, demonstrating the practical applications and benefits of this approach.

All the code used for this example is publicly available on GitHub:

https://github.com/nnCharles/avancio/tree/main/practical_llm

To run Neo4J locally, you will need to have the Java Development Kit (JDK) 17 installed. Here is how to do it on a Mac:

You will also need to install Neo4J. For this example, I chose to download only Neo4J Community, which is free. Here are the steps to get it started:

Access the Neo4J browser by navigating to 

 in your web browser. Unless set explicitly, the default username and password are set to 'neo4j'.

This ICIJ database contains information on more than 810,000 offshore entities that are part of the Pandora Papers, Paradise Papers, Bahamas Leaks, Panama Papers, and Offshore Leaks investigations. For illustrative purposes, we have decided to restrict this example to 1,000 entities and only officers located in Switzerland (CHE).

 statement. For example, this is how we loaded the Officer file:

 to interact with it. For this, we need to define some environment variables in a 

 library to handle environment variables. This function will load all the environment variables defined in the 

 which takes as parameters the graph and a LLM model in this case, we use 

 class to query our graph. The questions are converted to Cypher statements, whose outputs are used as context to generate the final answer:

We can quickly verify the data directly in the Neo4J database:

In conclusion, graph databases provide an efficient, visual, and scalable method for organizing data. With the advancements in LLMs, these databases can now be queried directly by converting natural language questions into Cypher statements automatically. This innovation significantly enhances the capabilities of financial crime investigators, offering them powerful new tools to support their research and uncover hidden relationships within complex data sets.

International Consortium of Investigative Journalists - Offshore Leaks Database

Charles Camp is a seasoned ML engineer with nine years of experience, specializing in NLP. He's also an AWS Solution Architect Associate, skilled in deploying ML solutions.

After writing his Master thesis, using machine learning to build predictive models in the medical sector, at Carnegie Mellon University, Charles took on the challenge of combatting money laundering at Credit Suisse Zurich (Switzerland), where he first began utilizing NLP to identify negative news.

For the past four years, Charles has been freelancing, collaborating with startups and industry leaders to realize their NLP projects. During the last two years, he's been diving into the latest LLM tech, extracting valuable insights from company documents, building chatbots, and developing powerful recommender systems.

Dive into a practical guide on integrating Large Language Models (LLMs) with Neo4j graph databases to analyze the ICIJ Offshore Leaks Database. Discover how to set up and query Knowledge Graphs using natural language, automate Cypher statement generation, and identify potential money laundering cases. Perfect for those looking to get started with LLMs, Neo4j, and advanced graph analysis techniques.

Financial Crime Investigation With Neo4J and LLMs

This article introduces a methodical approach to evaluating RAG, streamlining bench-marking, pipeline debugging, and gaining insights into errors.

Evaluating text generation models, such as Retrieval-Augmented Generation (RAG), presents a unique set of challenges compared to traditional machine learning assessment. Unlike standard models, evaluating text generation requires specialized methodologies due to the subjective and diverse nature of generated outputs. Metrics must capture not only quantitative aspects but also qualitative nuances, making evaluation highly dependent on the specific application domain. Consequently, assessing the performance of text generation models like RAG demands tailored approaches to effectively measure their effectiveness and quality.

While metrics like BLEU (Bilingual Evaluation Understudy) and ROUGE (Recall-Oriented Understudy for Gisting Evaluation) have traditionally been employed for evaluating text generation models, they often face limitations. Both BLEU and ROUGE metrics focus on measuring n-gram overlap between the generated text and reference text, which may overlook variations in vocabulary and word ordering.

Hence, evaluating the quality of chatbots has traditionally relied on gathering human feedback on a predefined set of commonly asked questions. However, advancements in AI capabilities have introduced a new trend known as AI-to-AI evaluation. This method involves feeding an AI model with the question asked and the corresponding response, tasking it with assessing the answer's quality and assigning a score. Remarkably, evaluations conducted by AI consistently align with those provided by humans, validating this approach. Moreover, it opens avenues for a significantly more cost-effective, rapid, and scalable approach to benchmarking models.

An additional challenge specific to chatbots is their complex composition, comprising multiple components. When faced with poor performance, identifying the problematic component becomes challenging. Is it the indexing, retrieval, or perhaps the prompt generating the response? This is where the RAG Triad [2] comes into play, offering three metrics to pinpoint the failing part of the RAG model:

If the Context Relevance metric indicates poor performance, it suggests that the RAG struggles to retrieve relevant information to construct the context for generating answers. In such cases, exploring different indexing methods, embeddings, or implementing re-ranking techniques might be necessary.

Conversely, if the Context Relevance is satisfactory but the Groundedness is lacking, it indicates that the generation prompt needs refinement. Despite having the correct context, the language model fails to effectively utilize it. Experimenting with different prompts, language models or fine-tuning the existing one may be beneficial.

Lastly, the Answer Relevance metric serves as a sanity check, ensuring that the generated answer aligns with the query and provides helpful information.

We will employ the identical code base as seen in 

 to demonstrate the utilization of AI-to-AI evaluation. For this purpose, we will utilize the 

 package, which not only incorporates the RAG triad but also offers an excellent user interface for gaining insights into the performance of the RAG model. Notably, it also grants the flexibility to define custom criteria for evaluating the quality of your RAG. To execute the provided code successfully, ensure that you have Python 3.11.7 installed, along with the specified dependencies.

Define the following variables in a .env file:

Download a sample text file of Paul Graham's essay for demonstration:

We reuse the naive RAG defined in Part 1.

 settings. All tables are stored in a local database, and we begin by clearing them.

Trulens tracks all requests made to the query engine and requests the provider (e.g., LLM) to assess the quality of responses based on a set of feedback functions.

 represents a list of questions we want our chatbot to answer. Various recorders are available; 

 is utilized with Llama-index, but there's also 

 functions are required. These functions calculate a score for a response based on specific criteria. Here's how they are defined:

For more details on the structure of Feedback functions, refer to [3], and you can find examples of already implemented feedback functions in [4].

In the end, you simply need to execute these commands to compare the performances of the various query engines you wish to test:

 application and furnish you with the URL required to visualize your results.

The leaderboard provides an overview of the scores for all your experiments. In our scenario, we utilized Answer Relevance, Context Relevance, and Groundedness as feedback metrics. Additionally, we can evaluate toxicity, conciseness, and various other customized success criteria.

For every entry, we can examine the succession of functions invoked and pinpoint the stage in the pipeline where failure occurs for each entry. We analyze token usage and prompt the chatbot to adhere precisely to expected behavior.

Discover a methodical approach to evaluating Retrieval-Augmented Generation (RAG) models using AI-to-AI evaluation and the RAG Triad. Learn how to streamline benchmarking, debug pipelines, and gain insights into errors. This guide covers trulens-eval implementation, visualization techniques, and practical tips for improving RAG performance in chatbots and text generation models.

Evaluating RAGs: The RAG Triad

Welcome to the second installment of our DIY Autonomous Mobile Robot (AMR) guide. If you haven't read 

 yet, we recommend checking it out before continuing.

Once the mechanical parts of the robot are successfully manufactured and assembled, we can proceed with the installation of electronics, wiring, and configuring components. Our project uses the Linorobot open-source software packages and hardware, which has a large community and is user-friendly, even for non-professionals.

Picture 1 shows the electronics block diagram and overall system architecture.

Picture 1 - OpenAMR mobile robot HW architecture

Safety sensors (US, IR, bumper), RPI camera and LiDAR

Batteries, Battery management system (BMS), and wireless charger

The components depicted in the hardware diagram can be found in the 

 folder. Indicated suppliers have been tested and proven reliable.

Comprehensive details on setting up the software, hardware, and firmware can be found in the 

Finally, in the new version of the Raspberry Pi 5, it's possible to use SSD memory connected via PCI Express. This not only increases the speed of data exchange but also enhances the reliability of this single-board computer, especially for industrial applications. The Raspberry Pi 5 is also available in various housings that provide greater dust and moisture resistance.

By the way, the usual method of using an SD card is also suitable. However, keep in mind that the SD card can wear out quickly, and the contacts may oxidize or come loose over time due to increased vibration, which is unlikely but still possible especially in a real industrial environment.

On the hardware diagram, you can see the main components used in mobile robots, as well as recommended options.

For mapping, robot localization and navigation, we use LIDAR, ROS2 (Robot Operating System) navigation stack and SLAM algorithm. LIDAR is also used to detect dynamic obstacles, ensuring the safety of the robot's movement for those around it. You can start with the cheapest RPLIDAR A1 with a range of up to 12 m, but it is recommended to use LiDAR with a longer range, which you can also choose from the same manufacturer on their SLAMTEC website.

To detect objects, people, and animals in the robot’s path, ultrasonic detectors are used for distances up to 3 meters, and IR sensors are used for distances up to 80 cm. Together, these sensors ensure the safe movement and turning of the robot. Correct sensor placement is crucial to ensure peripheral vision during turns, as LIDAR covers only a thin strip in height and is configured to detect obstacles ahead with a 120-degree viewing angle.

It is important to note that LIDAR operates at a certain height (about 30 cm) and with a 120-degree angle. Therefore, the use of ultrasonic and IR sensors is essential for ensuring traffic safety. If you place a box on top of the robot that is larger than the robot itself, ensure that the sensors cover this area as well. What is also important is to set up correct dimensions for the robot in the description file URDF - in 

 directory you can change the values according to the robot's specification/dimensions.

Optionally, you can also use a bumper, the model of which is indicated on the hardware diagram.

Don't neglect safety and place the emergency stop button in a visible location.

Let's take a closer look at connecting the motors, drivers, batteries, BMS, wireless charging receiver, and other components at the lower level of the hardware diagram.

You can find the documents for the motors and drivers in the 

 with all documents. The most challenging tasks are likely connecting the motors to the driver and the driver to the controller. The second most difficult task is connecting the batteries and the BMS. Everything else is relatively straightforward.

The BLDC motors offered are controlled using drivers. The control signal to the driver can be transmitted in the form of PWM or via an RS485/CAN interface. In the proposed open-source project Linorobot, control occurs via PWM. Please check Picture 2 for detailed information on wiring and control of the ZD driver and ZD BLDC motor. If you decide to use a ZLTEch hub motor - please check the corresponding folder for all detailed 

In case of using ZD drivers and motors, you will most likely need to install and connect encoders on each wheel. You can also read the Hall sensor feedback from the motor, but only in RS485 or CAN mode. This feedback may be enough to get a signal with sufficient feedback resolution from the wheels. An encoder is used to measure the number of wheel revolutions per minute, you can use any magnetic encoder. In our case, it is the AS5040A or AS5600 and a radial magnet. You can buy any board with such an encoder and secure it in a 3D-printed fastener, which you will find in the documentation in the general storage 3D models. The magnet is glued to the shaft, and the sensor is placed in close proximity to the magnet.

Knowing the dimensions of the wheel, you can easily calculate the distance traveled. However, wheels can sometimes slip or spin unevenly due to uneven surfaces, uneven loads, and other factors.

Therefore, we use several sensors to track the trajectory, acceleration, rotations and movement of the robot, such as an IMU and LIDAR with the SLAM algorithm. All these sources of odometry converge into a particle filter, specifically a Kalman filter. The purpose of this filter is to fuse the input signals from the three sources, providing a more accurate result than each source would individually.

As mentioned above, feedback can also be obtained from Hall sensors located inside the motor. This signal can replace the encoder signal. Although the encoder usually provides higher resolution, feedback from Hall sensors is usually sufficient for most robot applications.

You can find complete documentation on motors and drivers in the general document repository. This chassis uses a motor and driver from ZDmotor.

The connection and configuration of the motors are described in detail 

. Pay attention to the PID settings, as they are crucial for ensuring accurate movement.

Picture 2 - Wiring diagram for the ZD BLDC motor and driver

The versatile design of the OpenAMR can be adapted to create different types of robots for various logistics tasks, making it ideal for automating the movement of goods in small and medium-sized businesses. It can also be modified to carry tools or a roller cage, increasing its usefulness in a variety of scenarios.

One of the most commonly used and useful mechanisms is the elevator, which allows you to raise, move, and lower shelving units. Such a mechanism can be designed based on a simple scissor lift solution, though this design has a number of limitations.

Alternatively, you can use a ready-made module from the TZbot company. More information about different features and additional components that you would probably need you can find in the 

. This manufacturer can provide you with affordable components such as batteries, BMS, lifting or hooking mechanisms. You can also consider DalyElec as a reliable BMS supplier.

The cost of this robot does not exceed $3,000, making it a prime example of a low-cost DIY autonomous mobile robot suitable for industrial automation or warehouse logistics. Open-RMF can be used to integrate robots into a fleet.

When assembling the robot, you may have questions - this is normal. Most of the answers can be found in this guide upon re-reading, as well as in the description of the open-source project for Linorobot. For more detailed topics, basic knowledge can be obtained through online research. It is not feasible to cover every detail comprehensively at a basic level, as this article is intended to provide an overview rather than a complete robotics textbook.

This project requires basic knowledge of electronics, software, and mechanics. If you have any questions, comments, or want to discuss robotics, connect with us on 

The robot and its design were tested in real conditions. Based on the testing results, the design was optimized and manufacturability was increased.

These files are distributed without any express or implied warranty, including of merchantability, satisfactory quality and fitness for a particular purpose.

In the upcoming article of our AMR (Autonomous Mobile Robot) building series, we'll cover:

Stay tuned for this comprehensive conclusion to our AMR building journey!

After assembling the mechanical parts of your robot, it's time to install electronics, wiring, and configure components. This guide uses Linorobot open-source software, known for its user-friendly interface and strong community support, ideal even for non-professionals. Learn how to seamlessly integrate hardware and software in your DIY mobile robot project.

Hardware and Software Integration: Autonomous Mobile Robot DIY Guide

This is the third and final installment of our DIY Autonomous Mobile Robot (AMR) guide. If you haven’t had a chance to explore the 

 parts, we highly recommend reading them before diving into this section.

OpenAMR_UI is an open-source user interface designed for the intuitive control and management of autonomous mobile robots (AMRs) - its primary focus is on providing a user-friendly experience for effective AMR management. It offers a simple and understandable interface that allows users to monitor telemetry, set up tasks, configure waypoints, and define paths. Built with ease of exploitation, implementation, editing, and redesigning in mind, OpenAMR_UI is optimized for seamless integration with platforms like Linorobot and similar systems and well-suited for use with the Robot Operating System (ROS) Noetic distribution.

OpenAMR_UI facilitates the creation of detailed digital maps representing the operational environment of the AMR. These maps encompass information on walls, obstacles, and other relevant features. The software allows for:

Organizing multiple maps into logical groups for efficient management

Changing current maps for managing navigation through different floors, etc.

OpenAMR_UI empowers users to define specific routes for the AMR to navigate within the created maps. These routes essentially function as pre-programmed instructions, dictating the AMR's movement and obstacle avoidance strategies. The software allows:

The creation of multiple routes within a single map, catering to various tasks or objectives

Setting a specific task at each waypoint to execute it (in development)

With maps and routes established, OpenAMR_UI offers comprehensive control over the AMR's operation. Users can:

Initiate executing different functions on the robot

Monitor sensors value at a user-friendly interface

Direct the AMR to follow pre-defined routes

Visualize the AMR's real-time location and progress on the map interface

OpenAMR_UI prioritizes usability, even for individuals with limited robotics expertise. The intuitive interface simplifies map creation, route planning, robot control and monitoring statistics.

As an open-source project, OpenAMR_UI is freely available for use and modification. This grants users the flexibility to adapt it to their specific requirements and project goals.

OpenAMR_UI seamlessly integrates with ROS Noetic, a widely adopted framework for robot development. This compatibility ensures its functionality with a broad spectrum of robots and sensor systems.

OpenAMR_UI's functionality relies on a robust architecture composed of interconnected ROS nodes, standard packages, and communication libraries. Let's take a closer look at each of these components, the detailed software nodes, and the package architecture shown in Picture 8.

Picture 1 - User interface packages and nodes architecture

The MapNode node serves as the central hub for map and route management within OpenAMR_UI.

MapNode undertakes several key responsibilities:

Map management to save and load map data, ensuring the persistence of the robot's operational environment across sessions.

Route management to handle route creation, editing, and storage, allowing you to define various paths for the AMR.

Navigation control to launch the necessary ROS nodes responsible for robot navigation based on the defined routes.

Mapping control to trigger the launch of ROS nodes for map creation or updates, enabling you to modify the environment representation.

The WayPointNavNode node acts as the brain of the robot's navigation.

WayPointNavNode takes main stage when the AMR is actively following a route:

Once a route is selected, the WayPointNavNode seamlessly guides the robot along the predefined waypoints, executing the navigation commands with precision.

To handle additional functionalities related to various robot actuators, mechanisms, and sensors, you can utilize the Advanced Functions (optionally).

node serves as the user interface (UI) and the bridge between the human operator and the robot.

UI Application allows you to visualize maps, create routes, control the robot, and access information. This is the graphical interface you interact with, typically written on React framework.

Operating behind the scenes, the Flask server facilitates communication between the UI and the ROS nodes. It utilizes libraries like 

 to exchange data in a standardized format, ensuring seamless interaction.

 this ROS package acts as a translator, enabling communication between ROS and web technologies. It essentially bridges the gap between the robot's internal operations and the web-based UI.

 as the name suggests, this package facilitates video streaming. It allows you to view a live video feed from the robot's camera (if equipped) directly within the UI, providing valuable visual feedback on the robot's environment.

 this core ROS package provides a comprehensive framework for robot navigation. It encompasses various functionalities, including:

Localization (AMCL package): estimating the robot's position within the environment.

Path planning (move_base package): generating collision-free paths for the robot to follow to the goal.

Movement control (move_base package): sending appropriate velocity commands to the robot's wheels or motors to execute the planned path.

 this ROS package offers a popular SLAM (Simultaneous Localization and Mapping) solution. It allows the robot to build a map of its environment in real-time while simultaneously keeping track of its location within that map. This map information is often crucial for navigation planning.

 this ROS package acts as a server that manages the map data used by the navigation stack. It essentially loads a map (created beforehand using tools or provided by gmapping) and makes it accessible to other ROS nodes that require it for navigation purposes.

The Map page gives you a clear view of the robot’s world, there’s a map display to visualize the environment, real-time tracking of the robot’s location, waypoint markers for key navigation points, and interactive map buttons for various controls.The page features a clear map representation of the environment your robot operates in.

On the screen on the page, you can see red and blue triangles. The blue triangle indicates the robot's current position on the map, helping you track its movements, while the red triangles mark the waypoints you've defined for specific routes, providing a visual roadmap for the robot's planned path. There are buttons for zooming in and out and navigating the map, allowing you to focus on specific areas of the environment. These buttons function independently of ROS topics, ensuring a user-friendly experience.

sends a std_msgs/String message to the /ui_operation topic, which is parsed by other nodes in the ui_package to manage maps and groups - allowing you to create and delete map groups for better organization, as well as to create new maps, rename existing ones, and select the current active map for the robot.

Joystick movements are communicated via a geometry_msgs/Twist message sent to the /cmd_vel topic, where it is parsed by nodes responsible for controlling movement, enabling direct steering of the robot through a joystick interface on the map page.

The top bar displays the currently selected group and active map, providing context for your actions, while the messages section shows updates from various robot processes by visualizing std_msgs/String messages from the /ui_messages topic. Additionally, the Map page may feature a live video stream from the robot’s camera (if equipped), offering a real-time view of the robot’s surroundings to complement the map and enhance situational awareness, helping you monitor the robot’s route, identify obstacles, and better understand its environment.

The Route page empowers you to define specific paths for your robot to navigate within the maps you've created.

When you click on the buttons, UINode sends the std_msgs/String message to the topic “/ui_operation” and it will be parsed in other nodes of ui_package.

Design new routes by clicking and holding your mouse on the map at desired locations. These points become waypoints, dictating the robot's movement along the path. As you place each waypoint, the system automatically captures its coordinates and orientation. This ensures the robot follows a precise path. Once you've defined the waypoints for your route, click the "Save" button to solidify your plan. This makes the route available for selection and execution by the robot.

On the Route page you can delete routes you no longer need, rename routes for easy identification, edit existing routes by adding, removing, or repositioning waypoints as required, use the "Clear" button to erase all waypoints from a route, essentially starting over.

Also the Route page enables you to choose which route the robot will follow for its next navigation task. This selected route becomes the active one, guiding the robot's movement.

Monitoring system messages is similar to the Map page. The Messages section is a dedicated area on the Map page that displays informative messages from various robot operations. It receives and visualizes all std_msgs/String messages from the "ui_messages" topic.

The top of the page typically shows the current group, map, and route in use, providing clear context for your actions and indicating the route that will be used for navigation.

The Control page serves as your mission control center, allowing you to send navigation commands and guide your robot's movements. When you click on the buttons, UINode sends the std_msgs/String message to the topic “/ui_operation” and it will be parsed in other nodes of ui_package/ While it doesn't provide direct, physical control like a remote control car, it empowers you to strategically direct the robot's path.

Here is the list of route navigation buttons and commands:

 this button initiates navigation along the currently selected route. The system retrieves all the waypoints defined for the route (from file or database) and sends them one by one to the robot's navigation system. The robot meticulously follows each waypoint in sequence, completing the planned path.

 this button instructs the robot to return to its designated home position. The home point is typically set as the starting location used when building the map (often at coordinates [0.0, 0.0]). This functionality is helpful for bringing the robot back to a central location. In the future, we may use such a point, for example, to place a charging station there.

 use this button to direct the robot back to the previous waypoint on its current route. This allows you to retrace its steps if needed. If the robot is already at the first waypoint, it will loop around and navigate to the last waypoint.

 this button commands the robot to proceed to the next waypoint on its current route. This is useful for guiding it step-by-step along the planned path. If the robot is at the last waypoint, it will loop around and head to the first waypoint.

 this button brings the robot's movement to a halt, interrupting navigation along a route or manual control. This allows you to pause (stop) its operation and regain control.

 the Control page might include additional buttons labeled "functionN_value." These buttons, when pressed, transmit a specific string ("functionN_value") to a designated ROS topic "/ui_operation." This message can be intercepted and handled by custom functions you've programmed, enabling you to extend the robot's capabilities with unique actions.

 a dedicated section on the Map page (the same as on other pages) can display informative messages from various processes involved in robot operation. This section receives and visualize all std_msgs/String messages from topic “ui_messages”

The Info page acts as your information hub, providing a comprehensive overview of your robot's status and sensor data (robot telemetry).

You can gain valuable insights into the robot's current performance through live real-time data displays, which include:

 monitor the robot's current speed, allowing you to assess its progress and adjust navigation commands if necessary.

 the Info page might visually represent the robot's location on a map, complementing the data and offering a spatial understanding of its whereabouts.

The Info page retrieves sensor data by subscribing to the ROS topic std_msgs/String "/sensors." This topic acts as a central channel for sensor readings from various sources on the robot. The page might utilize circular bars to represent sensor values visually. These bars typically range from 0 to 100%, providing an easy-to-understand gauge for battery levels, temperatures, or other sensor data that can be interpreted as percentages.

These sensor readings, interpreted and visualized data can provide important information about the robot's environment and internal state. The specific sensors and data displayed will depend on your robot's configuration.

 monitor the battery levels of your robot (e.g., "batt1_value" or "batt2_value" for multiple batteries), ensuring timely recharging to avoid disruptions.

 keep an eye on temperature readings (e.g., "temp1_value" or "temp2_value" for multiple sensors) to identify any potential overheating issues.

 the page might display data from additional sensors labeled "sensN_value" (where N = 3, 4, 5, 6). These sensors could include things like range sensors, bump sensors, or any custom sensors you've integrated.

On the Info page, if your robot has a camera, a live video stream provides real-time visuals of the robot's surroundings, enhancing situational awareness by allowing you to observe the environment, identify obstacles, and understand interactions as the robot navigates.

Learn how to create an intuitive user interface for your DIY mobile robot project. This step-by-step guide covers designing controls for telemetry monitoring, task setup, waypoint configuration, and path definition. Perfect for hobbyists and developers working with platforms like Linorobot and ROS Noetic.

Creating the User Interface: Autonomous Mobile Robot DIY Guide

Discover the latest in AI, ML, Cyber Security, and more on Avancio Insights. Our expert articles and industry updates provide valuable knowledge to help you stay ahead in the tech world. Join our community of innovators today. Subscribe for updates!