How is the robot communicating to supervisor

[ringpy]

We are using the deepbot framework for avoid obstacles where robot created the message but unable to emit the same to supervisor or supervisor is not able to read. Can you help?

[eakirtas]

Hello @ringpy, are you using EmmiterReceiver scheme of deepbots? Could you please add some code snippet to check it?

[ringpy]

Hi @ManosMagnus , thanks for response. We are trying to recreate the avoid obstacle example.
For our robot controller, below code is creating message successfully but we are not able to send this to supervisor.
def handle_emitter(self):
data = self.create_message()
print("handle_emitter")
#print(data)
assert isinstance(data, Iterable)
string_message = " "
string_message = string_message.encode("utf-8")
self.emitter.send(string_message)

SupervisorController:
"""supervisor controller."""
import math
import numpy as np
import utilities as utils
from deepbots.supervisor.controllers.supervisor_emitter_receiver import
SupervisorCSV
from deepbots.supervisor.wrappers.keyboard_printer import KeyboardPrinter
from deepbots.supervisor.wrappers.tensorboard_wrapper import TensorboardLogger
from models.networks import DDPG

OBSERVATION_SPACE = 10
ACTION_SPACE = 2

DIST_SENSORS_MM = {'min': 0, 'max': 1023}
EUCL_MM = {'min': 0, 'max': 1.5}
ACTION_MM = {'min': -1, 'max': 1}
ANGLE_MM = {'min': -math.pi, 'max': math.pi}

print("Supervisor_Begin")

class FindTargetSupervisor(SupervisorCSV):
def init(self, robot, target, observation_space):
super(FindTargetSupervisor, self).init(emitter_name='emitter',
receiver_name='receiver')
self.robot_name = robot
self.target_name = target
self.robot = self.supervisor.getFromDef(robot)
self.target = self.supervisor.getFromDef(target)
self.observation = [0 for i in range(observation_space)]
self.findThreshold = 0.12
self.steps = 0
self.steps_threshold = 6000
self.message = []
self.should_done = False

def initialize_comms(self, emitter_name, receiver_name):
    emitter = self.getDevice(emitter_name)
    receiver = self.getDevice(receiver_name)
    receiver.enable(self.timestep)
    return emitter, receiver

def step(self, action):
    if super(Supervisor, self).step(self.timestep) == -1:
        exit()

    self.handle_emitter(action)
    return (
        self.get_observations(),
        self.get_reward(action),
        self.is_done(),
        self.get_info(),
    )
def handle_emitter(self, action):
def handle_receiver(self):
def get_observations(self):
    message = self.handle_receiver()

     observation = []
    self.message = []
    if message is not None:
        for i in range(len(message)):

            self.message.append(float(message[i]))

            observation.append(
                utils.normalize_to_range(float(message[i]),
                                         DIST_SENSORS_MM['min'],
                                         DIST_SENSORS_MM['max'], 0, 1))

        distanceFromTarget = utils.get_distance_from_target(
            self.robot, self.target)
        self.message.append(distanceFromTarget)
        distanceFromTarget = utils.normalize_to_range(
            distanceFromTarget, EUCL_MM['min'], EUCL_MM['max'], 0, 1)
        observation.append(distanceFromTarget)

        angleFromTarget = utils.get_angle_from_target(self.robot,
                                                      self.target,
                                                      is_true_angle=True,
                                                      is_abs=False)
        self.message.append(angleFromTarget)
        angleFromTarget = utils.normalize_to_range(angleFromTarget,
                                                   ANGLE_MM['min'],
                                                   ANGLE_MM['max'], 0, 1)
        observation.append(angleFromTarget)

    else:
        observation = [0 for i in range(OBSERVATION_SPACE)]

    self.observation = observation

    return self.observation

def empty_queue(self):
    self.message = None
    self.observation = None
    while self.supervisor.step(self.timestep) != -1:
        if self.receiver.getQueueLength() > 0:
            self.receiver.nextPacket()
        else:
            break

def get_reward(self, action):
    if (self.message is None or len(self.message) == 0
            or self.observation is None):
        return 0

    rf_values = np.array(self.message[:8])
    distance = self.message[8]

    reward = 0

    if self.steps > self.steps_threshold:
        return -10

    if utils.get_distance_from_target(self.robot,
                                      self.target) < self.findThreshold:
        return +10

    if np.abs(action[1]) > 1.5 or np.abs(action[0]) > 1.5:
        if self.steps > 10:
            self.should_done = True
        return -1

    if np.max(rf_values) > 500:
        if self.steps > 10:
            self.should_done = True
        return -1
    elif np.max(rf_values) > 100:
        return -0.5

    if (distance != 0):
        reward = (0.6 / distance)

    reward -= (self.steps / self.steps_threshold)
    return reward

def is_done(self):
    self.steps += 1
    distance = utils.get_distance_from_target(self.robot, self.target)

    if distance < self.findThreshold:
        print("======== + Solved + ========")
        return True

    if self.steps > self.steps_threshold or self.should_done:
        return True

    return False

def reset(self):
    print("Reset simulation")
    self.respawnRobot()
    self.steps = 0
    self.should_done = False
    self.message = None
    return self.observation

def get_info(self):
    pass

def respawnRobot(self):
    """
    This method reloads the saved CartPole robot in its initial state from the disk.
    """
    if self.robot is not None:
        # Despawn existing robot
        self.robot.remove()

    # Respawn robot in starting position and state
    rootNode = self.supervisor.getRoot(
    )  # This gets the root of the scene tree
    childrenField = rootNode.getField(
        'children'
    )  # This gets a list of all the children, ie. objects of the scene
    childrenField.importMFNode(
        -2, "Robot.wbo"
    )  # Load robot from file and add to second-to-last position

    # Get the new robot and pole endpoint references
    self.robot = self.supervisor.getFromDef(self.robot_name)
    self.target = self.supervisor.getFromDef(self.target_name)
    # Reset the simulation physics to start over
    self.supervisor.simulationResetPhysics()

    self._last_message = None

+++++++++++++++++++++++++++++++++++++++++++++++++++
Webot setup
DEF robot E-puck {
hidden position_0_0 122.40637515054988
hidden position_0_1 107.46764723864649
hidden rotation_1 -1 0 0 4.721753126551146
hidden rotation_2 1 0 0 0.17074858393249961
translation 0.6859147362154058 -6.396505326099894e-05 -0.10397221776402758
rotation -2.2311322997446737e-06 -0.9999999999954927 -2.0091526515012924e-06 -1.0438002781202578
name "robot"
controller "robot"
controllerArgs [
""
]
supervisor TRUE
emitter_channel 0
receiver_channel 0
}

DEF supervisor Robot {
children [
DEF emitter Emitter {
}
DEF receiver Receiver {
}
]
name "supervisor"
supervisor TRUE
}

[tsampazk]

@ringpy You should follow the provided tutorial and work from there.