Setting Up An Environment

In this tutorial, we will learn how to set up a Gym-compatible environment interface to control the Franka Emika Panda robot. This can be changed for multiple robots/different robots/more objects and sensors as well.

Prerequisites

A Franka Emika Panda robot is present and correctly configured in the environment.
An additional object (e.g., a ball) that is actively publishing its ground-truth state to an observation channel.

In this example we assume you are running a simulation that has the same set up seen below:

Setting up the Environment

Add a file called franka_env.py in the scripts folder.

This file defines a custom environment FrankaEnv that integrates with the Ark=robotics framework. It is designed to control and observe a Franka Emika Panda robot interacting with a ball object, either in simulation or the real world.

📦 File Structure

from ark.env.ark_env import ArkEnv
from arktypes import joint_group_command_t, joint_state_t, rigid_body_state_t
from arktypes.utils import pack, unpac

ArkEnv: Base class providing simulation and communication utilities.
arktypes: Message types used in action and observation channels.
pack/unpack: Helpers for serializing/deserializing messages to/from LCM.

🧠 Class Overview: `FrankaEnv`

class FrankaEnv(ArkEnv):

This class wraps around ArkEnv and defines an environment tailored for the Franka robot. It is compliant with standard RL environment conventions.

Key Elements

In this case we will define our action and observation channels as below

Action Channel:

Franka/joint_group_command/sim → joint_group_command_t

Sends desired joint positions.
Observation Channels:
- Franka/joint_states/sim → joint_state_t
  
  Receives joint angles from Franka.
- ball/ground_truth/sim → rigid_body_state_t
  
  Receives position and orientation of the ball.

🔧 Constructor


def __init__(self, config=None, sim=True)

Initializes the environment.
config: path or dict to the system configuration YAML.
sim: whether to run in simulation or real-world mode.


    environment_name = "Franka_Enviroment"

Sets the internal name of the environment (used for naming the Envrioment and Gym node).

    action_space = {
        'Franka/joint_group_command/sim': joint_group_command_t,
    }

Defines the action channel and its Ark message type.
Sends joint commands to Franka.


    observation_space = {
        'Franka/joint_states/sim': joint_state_t,
        'ball/ground_truth/sim': rigid_body_state_t,
    }

Defines two observation channels:
- Franka/joint_states/sim: receives robot joint angles.
- ball/ground_truth/sim: receives the pose of a ball in the scene.

    super().__init__(
        environment_name=environment_name,
        action_channels=action_space,
        observation_channels=observation_space,
        global_config=config,
        sim=sim
    )

Calls the parent ArkEnv constructor, which:
- Loads the config,
- Sets up communication,
- Creates action and observation spaces

🎮 Action Packing

def action_packing(self, action):

Converts a high-level action (list of joint angles) into a packed message to be sent over Ark Channels.
The input to these functions is what ever you pass into the step function when you call it from the gym.


    return {
        'Franka/joint_group_command/sim': pack.joint_group_command(
            name="all",
            cmd=action,
        )
    }

Uses joint_group_command helper to create a packed message.
This function should return a dictionary where the keys should match the action channel name, and the value is the message.

👁️ Observation Unpacking

def observation_unpacking(self, observation):

This function will return a dictionary with the keys being the observation channels and the values being the latest observations on these channels.

    ball_position = unpack.unpack_rigid_body_state(
        observation['ball/ground_truth/sim']
    )

Decodes the position and orientation of the ball.

	
    joint_states = unpack.unpack_joint_state(
        observation['Franka/joint_states/sim']

Decodes the joint angles from the robot.


    return [ball_position, joint_states]

In this case we return a list of the two decoded observations as a list
You can later process this into a vector or dictionary depending on use case.

🏁 Termination & Truncation Logic

def terminated_truncated_info(self, state, action, next_state):

Currently we will leave this blank but is a placeholder logic to decide whether the episode should terminate or truncate, for more advanced RL/IL examples Currently returns:

(False, False, None)

Can be extended based on task goals (e.g., if ball is reached or time limit exceeded).

🎯 Reward Function

def reward(self, state, action, next_state):

This can also be customised to reflect task-specific rewards (e.g., distance between gripper and ball).

🔄 Environment Reset

def reset_objects(self):

Called during env.reset(). Responsible for putting all objects back into their initial state.

You can call reset component function to reset the objects in the simulation.

  self.reset_component("Franka")

Resets the Franka robot using configuration or user-defined values.

Optional keyword arguments if resetting a robot is:

Base Position
Base Orientation
Initial Configuration

If left blank it will default to the values given in the config file.

self.reset_component("ball", base_position=[-0.5, 1, 0.5])

Likewise we can reset the ball to any position of our choosing.

Optional keyword arguments if resetting an object is:

Base Position
Base Orientation