How Brisa Robotics uses AWS to improve robotics operations

How Brisa Robotics uses AWS to improve robotics operations

In this post, you’ll learn how Brisa Robotics leverages Amazon Web Services (AWS) to collect, store, and process data from mixed fleets of vehicles to improve customer operations.

Brisa transforms non-autonomous machines into fleets of autonomous vehicles that collect data to help customers track key performance metrics and improve operations. Their mission is to enhance its customers’ efficiencies by leveraging existing infrastructure and reusing old machines instead of selling scraps and buying new ones. Brisa provides unique modular robotic kits to enhance material handling equipment (MHE) such as forklifts, palletizers, and telehandlers. These robotic kits are retrofitted for the MHE to include Brisa’s proprietary data collection platform. The kits support different use cases: stock-keeping unit (SKU) tracking, inspection (defects, objects, barcodes), and material movement. Getting better visibility into these use cases with data and metrics allows Brisa’s customers to optimize their warehouse layout and plan better.

Challenge: Build a flexible data collection solution

The largest brewing company in the world needed more visibility into their warehouse operations and stock to increase productivity and improve safety. So Brisa set out to create a solution to collect and stream data their customer could use to make better decisions.

Brisa is committed to avoiding infrastructure changes for customers so as not to increase customer overhead and maintenance costs. They wanted to help their customer without requiring them to change any of their existing infrastructures. Furthermore, Brisa needed to provide a single solution that would work for their customers with different workflows and requirements.

Depending on the customer, Brisa has different requirements to consider. For example, some customers want their data dashboard only available in their network, whereas others want it online. Additionally, some customers want a local computer that collects the data before sending it to the cloud, whereas others want the data transmitted directly from the robots. Brisa needed a flexible tool to run on different platforms for different scenarios.

The goal was to develop a flexible solution to collect and expose data and metrics for varied customers without customers needing to change any infrastructure.

Solution overview

Brisa developed a solution that collects data from the MHE robots; streams, processes, and stores it in AWS; and then pulls it into live custom dashboards for customers. This outcome occurs without changing the customer infrastructure, and the workflow can function with or without a stable internet connection.

• AWS IoT Greengrass V2 components are deployed to the robots, including pre-built components such as the stream manager.
• Data is collected from the client application running on the server (either the robot or an external machine on the robot network). This application can be run as a custom Greengrass component or outside of Greengrass.
• The stream manager component streams data directly to Amazon Kinesis Data Streams (Amazon KDS) and Amazon Simple Storage Service (Amazon S3).
• A Python based AWS Lambda function processes the raw data from the Kinesis data stream and stores it in an Amazon Timestream database.

Once data is in AWS, Brisa’s web application can query Amazon Timestream to collect data for their dashboards. You will learn more about this workflow below.

Collecting the data

Brisa collects data on the robots, such as object detection, robot position, robot speed, fork movements, and system monitoring. They do this using Robot Operating System 2 (ROS2), an open-source set of libraries and tools for building robot applications. ROS2 enables Brisa to construct and develop robot applications faster by using community-built nodes and devices such as simulation and build tooling. As a founding technical steering committee member for ROS2, AWS is a vital participant in the community, which results in a wide array of options for running ROS2 tooling in AWS. AWS gives Brisa the most scalable cloud platform with the deepest integrations with ROS2.

Streaming the data

Brisa subscribes to the ROS2 topic and forwards those events into the Kinesis data stream using the AWS IoT Greengrass V2 stream manager.. AWS IoT Greengrass is an open-source Internet of Things (IoT) edge runtime and cloud service that helps you build, deploy and manage IoT applications on your devices. You can use AWS IoT Greengrass to build edge applications using pre-built or custom software modules, called components, that can connect your edge devices to AWS services or third-party services. The stream manager component enables you to process data streams to transfer to the AWS Cloud from Greengrass core devices.

Brisa chose this Greengrass stream manager because it can run offline, under intermittent network conditions, without you having to worry about buffering and publishing data into AWS. The data is stored locally and compressed until an internet connection is active. Instead of managing this workflow, Brisa can send the data to the stream and focus on its unique robotic workflows. This setup is flexible to different customer needs as the Greengrass stream manager runs on the robots themselves or the local computer where the robots send data.

Brisa has a client application running and a server to start the stream manager. Depending on the customer, this server can be on the robot or an external machine on the robot network. For more information on setting up the stream manager, see the stream manager documentation and Deploy and Manage ROS Robots with AWS IoT Greengrass V2.

Brisa then used a ROS2 node to collect data from the sensors. They did this by creating a ROS2 package.

Sample commands to create a new ROS2 package:

cd ~
mkdir -p ws/src
pip install stream_manager
cd src
ros2 pkg create \
--package-format 3 \
--build-type ament_python \
sm_upload

Brisa publishes data to the Kinesis data stream and an Amazon S3 bucket through the Greengrass stream manager. They accomplish this by leveraging the stream manager Python SDK in their ROS nodes. Below is a sample ROS node similar to Brisa’s implementation that publishes data from ROS to the stream manager:

import json
import rclpy
from rclpy.node import Node
from stream_manager import (
ExportDefinition,
KinesisConfig,
MessageStreamDefinition,
StrategyOnFull,
StreamManagerClient,
)
STREAM_NAME = "SomeStream"
KINESIS_STREAM_NAME = "MyKinesisStream"
class StreamManagerPublisher(Node):
def __init__(self):
super().__init__("aws_iot_core_publisher")
timer_period = 3 # seconds
self.client = StreamManagerClient()
exports = ExportDefinition(
kinesis=[
KinesisConfig(
identifier="KinesisExport" + STREAM_NAME,
kinesis_stream_name=KINESIS_STREAM_NAME,
)
]
)
# Create the Status Stream if it does not exist already
try:
self.client.create_message_stream(
MessageStreamDefinition(
name=STREAM_NAME,
strategy_on_full=StrategyOnFull.OverwriteOldestData,
export_definition=exports,
)
)
except ConnectionRefusedError as e:
self.get_logger().error(f"Could not connect to the stream manager: {str(e)}")
raise
except Exception:
pass
# Create the message stream with the S3 Export definition.
self.client.create_message_stream(
MessageStreamDefinition(
name=STREAM_NAME,
strategy_on_full=StrategyOnFull.OverwriteOldestData,
export_definition=exports,
)
)
self.timer = self.create_timer(timer_period, self.timer_callback)
def timer_callback(self):
self.client.append_message(STREAM_NAME, json.dumps({"robot_id": "C3PO","timestamp": datetime.datetime.utcnow().isoformat(),"x": 1.0, "y": 1.1, "z": 3.0}).encode("utf-8"))
self.get_logger().info("Successfully appended S3 Task Definition to stream")
def main(args=None):
rclpy.init(args=args)
sm_publisher = StreamManagerPublisher()
rclpy.spin(sm_publisher)
sm_publisher.destroy_node()
rclpy.shutd