Orchestrazione delle attività

Gemini Robotics ER 2 può pianificare attività e ragionare sullo spazio, deducendo quali azioni intraprendere e quali oggetti spostare per raggiungere un obiettivo. Questa pagina mostra un esempio di esecuzione di un'operazione di pick-and-place tramite un'API robot personalizzata per orchestrare l'attività di posizionamento di un elemento in una ciotola.

Per il codice eseguibile completo, consulta il cookbook di robotica.

Chiama un'API robot personalizzata

Questo esempio mostra l'orchestrazione delle attività con un'API robot personalizzata. Introduce un'API fittizia progettata per un'operazione di pick-and-place. L'attività consiste nel raccogliere un blocco blu e posizionarlo in una ciotola arancione:

Un'immagine del blocco e della ciotola

Questo esempio utilizza le seguenti definizioni di API e strumenti di robot fittizi. Anziché restituire la sequenza di azioni come testo, il modello chiama queste funzioni tramite l'interfaccia di chiamata di funzione dell'SDK Google Gen AI:

Python

from google import genai
from google.genai import types

client = genai.Client(
    enterprise=True,
    project="your-project-id",
    location="global",
)

def move(x, y, high):
    print(f"Mock Robot: Moving to coordinates: {x}, {y}, {'high above table' if high else 'down at table level'}")

def setGripperState(opened):
    print(f"Mock Robot: {'Opening gripper' if opened else 'Closing gripper'}")

robot_origin_y = 300
robot_origin_x = 500

move_declaration = types.FunctionDeclaration(
    name="move",
    description="Moves the arm to the given coordinates.",
    parameters=types.Schema(
        type=types.Type.OBJECT,
        properties={
            "x": types.Schema(type=types.Type.INTEGER, description="X coordinate relative to the origin"),
            "y": types.Schema(type=types.Type.INTEGER, description="Y coordinate relative to the origin"),
            "high": types.Schema(type=types.Type.BOOLEAN, description="Set to True to lift the robot arm above the scene. Set to False to place the gripper on the surface."),
        },
        required=["x", "y", "high"],
    ),
)

set_gripper_state_declaration = types.FunctionDeclaration(
    name="setGripperState",
    description="Opens or closes the robot's gripper.",
    parameters=types.Schema(
        type=types.Type.OBJECT,
        properties={
            "opened": types.Schema(type=types.Type.BOOLEAN, description="True opens the gripper, False closes the gripper."),
        },
        required=["opened"],
    ),
)

robot_tools = types.Tool(function_declarations=[move_declaration, set_gripper_state_declaration])

L'esempio seguente invia il prompt e l'immagine al modello insieme alle definizioni degli strumenti. Quindi, esegue un loop dell'agente: dopo ogni risposta del modello, esegue tutte le chiamate di funzione richieste (move, setGripperState), invia i risultati al modello e ripete l'operazione finché il modello non smette di chiamare funzioni o non viene raggiunto il limite di passaggi.

Python

with open("robot-api-example.png", "rb") as f:
    img_bytes = f.read()

prompt = (
    "You are a robotic arm with six degrees-of-freedom. "
    f"The origin point for calculating the moves is at normalized point y={robot_origin_y}, x={robot_origin_x}. "
    "Use this as the new (0,0) for calculating moves, allowing x and y to be negative.\n\n"
    "Find the blue block and the orange bowl. Calculate their coordinates relative to the origin.\n"
    "Perform a pick and place operation where you pick up the blue block and place it into the orange bowl. "
    "Call the appropriate sequence of functions to complete this operation."
)

contents = [
    types.Content(role="user", parts=[
        types.Part.from_bytes(data=img_bytes, mime_type="image/png"),
        types.Part(text=prompt),
    ])
]

print("\n--- Executing Orchestrated Plan ---")

max_steps = 15  # Safety limit to prevent infinite loops
step_count = 0

# The agentic loop
while step_count < max_steps:
    step_count += 1

    response = client.models.generate_content(
        model="gemini-robotics-er-2-preview",
        contents=contents,
        config=types.GenerateContentConfig(
            tools=[robot_tools],
            thinking_config=types.ThinkingConfig(
                thinking_level=types.ThinkingLevel.LOW
            ),
        ),
    )

    # Add the model response to the conversation history
    contents.append(response.candidates[0].content)

    # Check for function calls
    function_calls = [
        part for part in response.candidates[0].content.parts if part.function_call
    ]

    if not function_calls:
        # The model is done calling functions
        print("Sequence complete.")
        print(f"Model Summary: {response.text}")
        break

    # Execute function calls and collect results
    function_response_parts = []
    for part in function_calls:
        fc = part.function_call
        if fc.name == "move":
            move(**fc.args)
        elif fc.name == "setGripperState":
            setGripperState(**fc.args)

        function_response_parts.append(
            types.Part.from_function_response(
                name=fc.name,
                response={"status": "success"},
            )
        )

    # Send the function results back to the model
    contents.append(types.Content(role="user", parts=function_response_parts))

Di seguito è riportato un possibile output del modello basato sul prompt e sull'API del robot fittizio. L'output include i risultati delle chiamate di funzione del robot che il modello ha sequenziato:

--- Executing Orchestrated Plan ---
Mock Robot: Opening gripper
Mock Robot: Moving to coordinates: 160, 440, high above table
Mock Robot: Moving to coordinates: 160, 440, down at table level
Mock Robot: Closing gripper
Mock Robot: Moving to coordinates: 160, 440, high above table
Mock Robot: Moving to coordinates: -250, 60, high above table
Mock Robot: Moving to coordinates: -250, 60, down at table level
Mock Robot: Opening gripper
Mock Robot: Moving to coordinates: -250, 60, high above table
Sequence complete.
Model Summary: I have completed the task of picking up the blue block and placing it into the orange bowl.

Passaggi successivi

Per scoprire di più su Gemini Robotics ER 2, consulta le seguenti risorse: