7.1.6-ROS-uitvoeringsbeheer

ROS-nodes beheren met launch-bestanden

Launch-bestanden in ROS zijn XML-bestanden die worden gebruikt om meerdere ROS-nodes efficiënt te starten en te beheren. Deze sectie behandelt de verschillende tags die beschikbaar zijn in launch-bestanden, inclusief hun attributen en gebruiksscenario's.

De <launch>-tag

De <launch>-tag is de root van elk launch-bestand en fungeert als container voor alle andere tags.

1. Attributen

  • deprecated="afkeuringsverklaring"
    Geeft aan de gebruiker aan dat het huidige launch-bestand is afgekeurd.

2. Onderliggende tags

  • Alle andere tags in een launch-bestand zijn onderliggende elementen van de <launch>-tag.

Voorbeeld:

xml
<launch>
    <!-- Other tags go here -->
</launch>

De <node>-tag

De <node>-tag wordt gebruikt om een te lanceren ROS-node op te geven. Het is een van de meest gebruikte tags in een launch-bestand. Houd er rekening mee dat het commando roslaunch niet garandeert dat nodes in de gedeclareerde volgorde starten, omdat het opstartproces van nodes multi-threaded is.

1. Attributen

  • pkg="package_name"
    Geeft het pakket aan waartoe de node behoort.

  • type="nodeType"
    Het type node, dat overeenkomt met de naam van het uitvoerbare bestand.

  • name="nodeName"
    De naam van de node binnen de ROS-netwerktopologie.

  • args="xxx xxx xxx" (optioneel)
    Geeft argumenten door aan de node.

  • machine="machine_name"
    Geeft de machine aan waarop de node moet worden gelanceerd.

  • respawn="true | false" (optioneel)
    Bepaalt of de node automatisch opnieuw moet starten als hij wordt afgesloten.

  • respawn_delay="N" (optioneel)
    Indien respawn op true staat, definieert dit een vertraging van N seconden voordat de node opnieuw wordt gestart.

  • required="true | false" (optioneel)
    Geeft aan of deze node kritisch is. Indien op true gezet, wordt het hele roslaunch-proces beëindigd als de node wordt afgesloten.

  • ns="namespace" (optioneel)
    Lanceert de node binnen de opgegeven namespace.

  • clear_params="true | false" (optioneel)
    Wist alle parameters in de privé-namespace van de node voordat de node wordt gestart.

  • output="log | screen" (optioneel)
    Bepaalt waar de log-uitvoer naartoe moet: een logbestand of het scherm. De standaard is log.

2. Onderliggende tags

  • env: Voor het instellen van omgevingsvariabelen.
  • remap: Voor het opnieuw toewijzen van topic- of servicenamen.
  • rosparam: Voor het instellen van parameters.
  • param: Voor het instellen van parameters.

Voorbeeld:

xml
<launch>
    <node name="node1" pkg="my_package" type="node_executable" output="screen" respawn="true" respawn_delay="5">
        <param name="param_name" value="param_value"/>
        <remap from="/old_topic" to="/new_topic"/>
    </node>
</launch>

De <include>-tag

De <include>-tag wordt gebruikt om een ander XML-launch-bestand op te nemen in het huidige launch-bestand. Dit maakt modulaire en herbruikbare configuraties mogelijk.

1. Attributen

  • file="$(find package_name)/path/to/file.launch"
    Geeft het pad op naar het launch-bestand dat moet worden opgenomen.

  • ns="namespace" (optioneel)
    Neemt het bestand op onder de opgegeven namespace.

2. Onderliggende tags

  • env: Voor het instellen van omgevingsvariabelen.
  • arg: Voor het doorgeven van argumenten aan het opgenomen launch-bestand.

Voorbeeld:

xml
<launch>
    <include file="$(find my_package)/launch/another_launch_file.launch" ns="my_namespace"/>
</launch>

De <remap>-tag

De <remap>-tag wordt gebruikt om ROS topic- of servicenamen opnieuw toe te wijzen. Dit is handig om naamconflicten te vermijden of om namen tussen verschillende nodes te standaardiseren.

1. Attributen

  • from="xxx"
    De oorspronkelijke topic- of servicenaam.

  • to="yyy"
    De nieuwe naam voor de topic of service.

2. Onderliggende tags

  • Geen

Voorbeeld:

xml
<launch>
    <node name="node1" pkg="my_package" type="node_executable">
        <remap from="/old_topic" to="/new_topic"/>
    </node>
</launch>

De <param>-tag

De <param>-tag wordt gebruikt om parameters in te stellen op de ROS Parameter Server. De bron van de parameter kan rechtstreeks in de tag worden gespecificeerd of vanuit een extern bestand worden geladen. Wanneer gebruikt binnen een <node>-tag, wordt de parameter ingesteld in de privé-namespace van de node.

1. Attributen

  • name="namespace/parameter_name"
    De naam van de parameter, die een namespace kan bevatten.

  • value="xxx" (optioneel)
    Definieert de waarde van de parameter. Indien weggelaten, moet een extern bestand als bron van de parameter worden gespecificeerd.

  • type="str | int | double | bool | yaml" (optioneel)
    Specificeert het type van de parameter. Indien niet gespecificeerd, zal roslaunch proberen het type af te leiden uit de waarde:

    • Getallen met een . worden geparseerd als floating-point (double).
    • De strings "true" en "false" worden geparseerd als booleaanse waarden (hoofdletterongevoelig).
    • Al het andere wordt geparseerd als string.

2. Onderliggende tags

  • Geen

Voorbeeld:

xml
<launch>
    <node name="node1" pkg="my_package" type="node_executable">
        <param name="namespace/param_name" value="param_value" type="str"/>
    </node>
</launch>

De <rosparam>-tag

Met de <rosparam>-tag kunnen parameters worden geladen vanuit een YAML-bestand, geëxporteerd naar een YAML-bestand of verwijderd. Wanneer gebruikt binnen een <node>-tag, worden de parameters als privé beschouwd.

1. Attributen

  • command="load | dump | delete" (optioneel, standaard load)
    Specificeert de uit te voeren bewerking: parameters laden vanuit een bestand, ze exporteren naar een bestand of ze verwijderen.

  • file="$(find package_name)/path/to/file.yaml"
    Specificeert het YAML-bestand om parameters te laden of te exporteren.

  • param="parameter_name"
    De naam van de parameter.

  • ns="namespace" (optioneel)
    Specificeert de namespace voor de parameters.

2. Onderliggende tags

  • Geen

Voorbeeld:

xml
<launch>
    <rosparam file="$(find my_package)/config/params.yaml" command="load" ns="my_namespace"/>
</launch>

De <group>-tag

De <group>-tag wordt gebruikt om nodes en andere tags te groeperen, en maakt het mogelijk om een namespace of andere instellingen toe te passen op de groep als geheel.

1. Attributen

  • ns="namespace" (optioneel)
    Past een namespace toe op alle nodes en parameters binnen de groep.

  • clear_params="true | false" (optioneel)
    Wist alle parameters in de namespace van de groep voordat de groep wordt gestart. Gebruik met voorzichtigheid, aangezien dit kritieke parameters kan verwijderen.

2. Onderliggende tags

  • Elke tag behalve de <launch>-tag kan een kind zijn van <group>.

Voorbeeld:

xml
<launch>
    <group ns="my_namespace" clear_params="true">
        <node name="node1" pkg="my_package" type="node_executable"/>
        <node name="node2" pkg="my_package" type="node_executable"/>
    </group>
</launch>

De <arg>-tag

De <arg>-tag wordt gebruikt om dynamische argumenten te definiëren die tijdens runtime aan het launch-bestand kunnen worden doorgegeven, vergelijkbaar met functieparameters. Dit verhoogt de flexibiliteit van launch-bestanden.

1. Attributen

  • name="argument_name"
    De naam van het argument.

  • default="default_value" (optioneel)
    Specificeert de standaardwaarde voor het argument.

  • value="value" (optioneel)
    Specificeert de waarde voor het argument. Kan niet tegelijk met default worden gebruikt.

  • doc="description"
    Geeft een beschrijving van het argument.

2. Onderliggende tags

  • Geen

3. Voorbeeld

Launch-bestand met argumentsyntaxis, hello.launch:

xml
<launch>
    <arg name="robot_name" default="my_robot"/>
    <param name="robot_name" value="$(arg robot_name)"/>
</launch>

Aanroep vanaf de command-line met argumentdoorgifte:

bash
roslaunch hello.launch robot_name:=robot_value

ROS-werkruimte-overlay

Stel u voor dat u twee aangepaste werkruimten hebt, Workspace A en Workspace B, beide met een pakket genaamd turtlesim. Daarnaast bevat de ingebouwde werkruimte van het systeem ook een pakket genaamd turtlesim. Wanneer u het pakket turtlesim aanroept, welke wordt dan gebruikt?

Implementatiestappen

Stap 0: Maak werkruimten A en B aan

Maak eerst twee aparte werkruimten, A en B. Maak in elke werkruimte een pakket genaamd turtlesim.

Stap 1: Wijzig het bestand ~/.bashrc

Voeg de volgende regels toe aan uw ~/.bashrc-bestand om de setup-bestanden voor beide werkruimten te sourcen:

bash
source /home/user/path/to/workspaceA/devel/setup.bash
source /home/user/path/to/workspaceB/devel/setup.bash

Vervang /home/user/path/to/ door de werkelijke paden naar uw werkruimten.

Stap 2: Laad omgevingsvariabelen

Open een nieuwe terminal en voer het volgende commando uit om de bijgewerkte omgevingsvariabelen te laden:

bash
source ~/.bashrc

Stap 3: Controleer ROS-omgevingsvariabelen

Voer het volgende uit om de paden van de ROS-pakketten te verifiëren:

bash
echo $ROS_PACKAGE_PATH

Resultaat: De uitvoer toont de paden in deze volgorde: Workspace B → Workspace A → Ingebouwde werkruimte van het systeem.

Stap 4: Roep het pakket turtlesim aan

Voer nu het volgende commando uit om naar het pakket turtlesim te navigeren:

bash
roscd turtlesim

Resultaat: U wordt doorverwezen naar het pakket turtlesim binnen Workspace B.

Omgaan met naamconflicten van ROS-nodes

Scenario

In ROS heeft elke node een naam die wordt gedefinieerd tijdens de initialisatie van de node. In C++ wordt dit gedaan met de API ros::init(argc, argv, "node_name");, terwijl het in Python wordt gedaan met rospy.init_node("node_name"). In een ROS-netwerktopologie moeten nodes unieke namen hebben omdat het delen van dezelfde naam door meerdere nodes verwarring kan veroorzaken bij het aanroepen. Concreet: als een node met een dubbele naam wordt gestart, wordt de bestaande node met die naam automatisch afgesloten. Maar wat als u meerdere instanties van dezelfde node moet uitvoeren of met naamconflicten moet omgaan?

ROS biedt twee strategieën om met dergelijke situaties om te gaan: namespaces en naamremapping.

  • Namespaces voegen een prefix toe aan namen van nodes.
  • Naamremapping wijst een alias toe aan een nodenaam.

Beide strategieën kunnen naamconflicten van nodes oplossen en kunnen op verschillende manieren worden geïmplementeerd:

  1. Met het commando rosrun.
  2. Via launch-bestanden.
  3. In de code van de node.

Deze sectie laat zien hoe u deze drie methoden kunt gebruiken om naamconflicten van nodes te voorkomen.

Voorbeeldscenario

Laten we twee turtlesim_node-nodes starten. Als u twee terminals opent en de nodes direct start zonder wijzigingen, wordt de eerste node afgesloten wanneer u de tweede start. U ziet een waarschuwingsbericht:

plaintext
[ WARN] [1578812836.351049332]: Shutdown request received.
[ WARN] [1578812836.351207362]: Reason given for shutdown: [new node registered with same name]

Aangezien nodes niet dezelfde naam kunnen delen, verkennen we verschillende strategieën om dit probleem aan te pakken.

rosrun gebruiken voor namespaces en remapping

1. Een namespace instellen met rosrun

U kunt een namespace voor een node instellen met de volgende syntaxis:

bash
rosrun package_name node_name __ns:=/new_namespace

Voorbeeld:

bash
rosrun turtlesim turtlesim_node __ns:=/xxx
rosrun turtlesim turtlesim_node __ns:=/yyy

Met deze commando's draaien beide nodes zonder problemen.

Resultaten:

Gebruik rosnode list om de nodes te controleren:

plaintext
/xxx/turtlesim
/yyy/turtlesim

2. Nodenamen opnieuw toewijzen met rosrun

U kunt ook de naam van een node opnieuw toewijzen, waardoor deze in feite een alias krijgt, met de volgende syntaxis:

bash
rosrun package_name node_name __name:=new_name

Voorbeeld:

bash
rosrun turtlesim turtlesim_node __name:=t1
rosrun turtlesim turtlesim_node __name:=t2

Met deze commando's draaien beide nodes onder hun nieuwe namen.

Resultaten:

Gebruik rosnode list om de nodes te controleren:

plaintext
/t1
/t2

3. Namespace en naamremapping combineren met rosrun

U kunt beide technieken combineren door tegelijk een namespace in te stellen en de nodenaam opnieuw toe te wijzen:

bash
rosrun package_name node_name __ns:=/new_namespace __name:=new_name

Voorbeeld:

bash
rosrun turtlesim turtlesim_node __ns:=/xxx __name:=tn

Resultaten:

Gebruik rosnode list om de node te controleren:

plaintext
/xxx/tn

U kunt de namespace ook instellen met een omgevingsvariabele voordat u de node start:

bash
export ROS_NAMESPACE=xxxx

Launch-bestanden gebruiken voor namespaces en remapping

In launch-bestanden bevat de <node>-tag twee belangrijke attributen: name en ns. Deze worden gebruikt voor respectievelijk naamremapping en het instellen van namespaces. Het beheren van namespaces en naamremapping via een launch-bestand is eenvoudig.

1. Voorbeeld launch-bestand

Hier ziet u hoe u namespaces en naamremapping in een launch-bestand instelt:

xml
<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="t1" />
    <node pkg="turtlesim" type="turtlesim_node" name="t2" />
    <node pkg="turtlesim" type="turtlesim_node" name="t1" ns="hello"/>
</launch>

In dit voorbeeld is het attribuut name verplicht, terwijl ns optioneel is.

2. Het launch-bestand uitvoeren

Voer het launch-bestand uit en gebruik vervolgens rosnode list om de resultaten te zien:

plaintext
/t1
/t2
/hello/t1

Namespaces en remapping in code instellen

Als u aangepaste nodes implementeert, hebt u meer flexibiliteit om namespaces en naamremapping rechtstreeks in uw code in te stellen.

1. C++-implementatie: naamremapping

U kunt een naamalias instellen met de volgende code:

cpp
ros::init(argc, argv, "zhangsan", ros::init_options::AnonymousName);

Uitvoering:

Dit voegt een tijdstempel toe aan de naam van de node, zodat deze uniek is.

2. C++-implementatie: een namespace instellen

U kunt een namespace rechtstreeks in code instellen, zoals:

cpp
std::map<std::string, std::string> map;
map["__ns"] = "xxxx";
ros::init(map, "wangqiang");

Uitvoering:

Hiermee wordt een namespace voor de node ingesteld, zodat deze zonder conflicten kan draaien.

3. Python-implementatie: naamremapping

In Python kunt u vergelijkbare functionaliteit bereiken met de volgende code:

python
rospy.init_node("lisi", anonymous=True)

Topicnaam-remapping in ROS

In ROS stelt topicnaam-remapping u in staat om de naam van een topic waarop een node zich abonneert of publiceert te wijzigen zonder de code van de node aan te passen. Dit is met name nuttig bij het integreren van meerdere nodes die via verschillende topicnamen moeten communiceren. Er zijn drie hoofdmethoden om topicnamen in ROS opnieuw toe te wijzen:

  1. Met het commando rosrun.
  2. Via launch-bestanden.
  3. Door de code in C++ of Python rechtstreeks aan te passen.

rosrun gebruiken om topics opnieuw toe te wijzen

De syntaxis voor het opnieuw toewijzen van een topicnaam met rosrun is:

bash
rosrun package_name node_name old_topic_name:=new_topic_name

Voorbeeld: teleop_twist_keyboard integreren met turtlesim

Er zijn twee manieren om communicatie op te zetten tussen de node teleop_twist_keyboard en de weergavenode turtlesim:

1. Oplossing 1: topic van teleop_twist_keyboard opnieuw toewijzen

In deze aanpak wijzen we de topic van de node teleop_twist_keyboard opnieuw toe aan /turtle1/cmd_vel.

  • Start de toetsenbord-besturingsnode:

    bash
    rosrun teleop_twist_keyboard teleop_twist_keyboard.py /cmd_vel:=/turtle1/cmd_vel

  • Start de turtlesim-weergavenode:

    bash
    rosrun turtlesim turtlesim_node

Beide nodes communiceren correct via de topic /turtle1/cmd_vel.

2. Oplossing 2: topic van turtlesim opnieuw toewijzen

Alternatief kunnen we de topic van de node turtlesim opnieuw toewijzen aan /cmd_vel.

  • Start de toetsenbord-besturingsnode:

    bash
    rosrun teleop_twist_keyboard teleop_twist_keyboard.py

  • Start de turtlesim-weergavenode:

    bash
    rosrun turtlesim turtlesim_node /turtle1/cmd_vel:=/cmd_vel

Beide nodes communiceren correct via de topic /cmd_vel.

Launch-bestanden gebruiken om topics opnieuw toe te wijzen

U kunt topics ook opnieuw toewijzen in een launch-bestand. De syntaxis voor het opnieuw toewijzen van een topic in een launch-bestand is:

xml
<node pkg="package_name" type="node_type" name="node_name">
    <remap from="original_topic" to="new_topic" />
</node>

Voorbeeld: teleop_twist_keyboard integreren met turtlesim met behulp van launch-bestanden

Ook hier zijn er twee oplossingen:

1. Oplossing 1: topic van teleop_twist_keyboard opnieuw toewijzen

In deze aanpak wijzen we de topic van de node teleop_twist_keyboard opnieuw toe aan /turtle1/cmd_vel.

xml
<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="t1" />
    <node pkg="teleop_twist_keyboard" type="teleop_twist_keyboard.py" name="key">
        <remap from="/cmd_vel" to="/turtle1/cmd_vel" />
    </node>
</launch>

Beide nodes communiceren correct.

2. Oplossing 2: topic van turtlesim opnieuw toewijzen

In deze aanpak wijzen we de topic van de node turtlesim opnieuw toe aan /cmd_vel.

xml
<launch>
    <node pkg="turtlesim" type="turtlesim_node" name="t1">
        <remap from="/turtle1/cmd_vel" to="/cmd_vel" />
    </node>
    <node pkg="teleop_twist_keyboard" type="teleop_twist_keyboard.py" name="key" />
</launch>

Beide nodes communiceren correct.

Topics opnieuw toewijzen in code

De topicnaam in ROS wordt beïnvloed door de namespace van de node, de naam van de node en de naam van de topic zelf. Topicnamen kunnen over het algemeen in drie typen worden ingedeeld:

  1. Globaal: De topicnaam is absoluut en begint met /, waardoor deze onafhankelijk is van de namespace van de node.
  2. Relatief: De topicnaam is relatief en begint niet met /, wat betekent dat hij wordt geïnterpreteerd binnen de namespace van de node.
  3. Privé: De topicnaam is privé en begint met ~, wat betekent dat hij wordt opgelost ten opzichte van de privé-namespace van de node.

Laten we deze concepten verkennen aan de hand van voorbeelden in C++ en Python.

1. C++-implementatie

Voorbereiding van het voorbeeld:

  1. Initialiseer de node met een naam:

    cpp
    ros::init(argc, argv, "hello");

  2. Stel verschillende soorten topicnamen in.

  3. Geef bij het starten van de node een argument __ns:=xxx mee.

  4. Gebruik na het starten van de node rostopic om de topicinformatie te controleren.

Globale topicnaam

Globale topicnamen beginnen met / en zijn onafhankelijk van de naam of namespace van de node.

  • Voorbeeld 1:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("/chatter", 1000);

    Resultaat: /chatter

  • Voorbeeld 2:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("/chatter/money", 1000);

    Resultaat: /chatter/money

Relatieve topicnaam

Relatieve topicnamen beginnen niet met / en worden opgelost ten opzichte van de namespace van de node.

  • Voorbeeld 1:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("chatter", 1000);

    Resultaat: xxx/chatter

  • Voorbeeld 2:

    cpp
    ros::Publisher pub = nh.advertise<std_msgs::String>("chatter/money", 1000);

    Resultaat: xxx/chatter/money

Privé-topicnaam

Privé-topicnamen beginnen met ~ en worden opgelost ten opzichte van de privé-namespace van de node.

  • Voorbeeld 1:

    cpp
    ros::NodeHandle nh("~");
ros::Publisher pub = nh.advertise<std_msgs::String>("chatter", 1000);

    Resultaat: /xxx/hello/chatter

  • Voorbeeld 2:

    cpp
    ros::NodeHandle nh("~");
ros::Publisher pub = nh.advertise<std_msgs::String>("chatter/money", 1000);

    Resultaat: /xxx/hello/chatter/money

  • Speciaal geval: Bij het gebruik van ~, als de topicnaam met / begint, wordt de topicnaam als absoluut behandeld.

    cpp
    ros::NodeHandle nh("~");
ros::Publisher pub = nh.advertise<std_msgs::String>("/chatter/money", 1000);

    Resultaat: /chatter/money

Python-implementatie

Voorbereiding van het voorbeeld:

  1. Initialiseer de node met een naam:

    python
    rospy.init_node("hello")

  2. Stel verschillende soorten topicnamen in.

  3. Geef bij het starten van de node een argument __ns:=xxx mee.

  4. Gebruik na het starten van de node rostopic om de topicinformatie te controleren.

Globale topicnaam

Globale topicnamen beginnen met / en zijn onafhankelijk van de naam of namespace van de node.

  • Voorbeeld 1:

    python
    pub = rospy.Publisher("/chatter", String, queue_size=1000)

    Resultaat: /chatter

  • Voorbeeld 2:

    python
    pub = rospy.Publisher("/chatter/money", String, queue_size=1000)

    Resultaat: /chatter/money

Relatieve topicnaam

Relatieve topicnamen beginnen niet met / en worden opgelost ten opzichte van de namespace van de node.

  • Voorbeeld 1:

    python
    pub = rospy.Publisher("chatter", String, queue_size=1000)

    Resultaat: xxx/chatter

  • Voorbeeld 2:

    python
    pub = rospy.Publisher("chatter/money", String, queue_size=1000)

    Resultaat: xxx/chatter/money

Privé-topicnaam

Privé-topicnamen beginnen met ~ en worden opgelost ten opzichte van de privé-namespace van de node.

  • Voorbeeld 1:

    python
    pub = rospy.Publisher("~chatter", String, queue_size=1000)

    Resultaat: /xxx/hello/chatter

  • Voorbeeld 2:

    python
    pub = rospy.Publisher("~chatter/money", String, queue_size=1000)

    Resultaat: /xxx/hello/chatter/money

Parameters instellen in ROS

In ROS worden parameters gebruikt om nodes tijdens runtime te configureren. Ze kunnen op verschillende manieren worden ingesteld: met het commando rosrun, binnen launch-bestanden of rechtstreeks in de code. Parameters kunnen globaal, relatief of privé zijn, afhankelijk van hoe ze worden gedefinieerd.

Parameters instellen met rosrun

U kunt parameters instellen bij het lanceren van een node met het commando rosrun. De syntaxis voor het instellen van parameters is:

bash
rosrun package_name node_name _parameter_name:=parameter_value

Voorbeeld: een parameter instellen voor de Turtlesim-node

Laten we de turtlesim_node starten en een parameter A = 100 instellen.

bash
rosrun turtlesim turtlesim_node _A:=100

De parameters controleren

U kunt het volgende commando gebruiken om alle parameters weer te geven en de resultaten te controleren:

bash
rosparam list

Uitvoer:

plaintext
/turtlesim/A
/turtlesim/background_b
/turtlesim/background_g
/turtlesim/background_r

Uitleg: De parameter A heeft de naam van de node als prefix (/turtlesim/), wat aangeeft dat wanneer rosrun wordt gebruikt om een parameter in te stellen, dit gebeurt in de privé-namespace-modus.

Parameters instellen in launch-bestanden

Zoals eerder besproken kunnen parameters worden ingesteld in launch-bestanden met behulp van de tags <param> of <rosparam>. Parameters die buiten de <node>-tag worden ingesteld zijn globaal, terwijl die binnen de <node>-tag privé zijn en relatief aan de namespace van de node.

Voorbeeld: parameters instellen met de <param>-tag

Hier is een voorbeeld waarin we een globale en een privé-parameter instellen:

xml
<launch>
    <param name="p1" value="100" />
    <node pkg="turtlesim" type="turtlesim_node" name="t1">
        <param name="p2" value="100" />
    </node>
</launch>

De parameters controleren

Na het uitvoeren van het launch-bestand kunt u de parameters controleren met:

bash
rosparam list

Uitvoer:

plaintext
/p1
/t1/p2

Uitleg: De parameter p1 is globaal, terwijl p2 privé is voor de node t1, zoals aangegeven door de namespace.

Parameters instellen in code

Parameters in code instellen biedt meer flexibiliteit, waardoor u programmatisch globale, relatieve en privé-parameters kunt definiëren.

1. C++-implementatie

In C++ kunnen parameters worden ingesteld met de API ros::param of via een ros::NodeHandle-object.

1.1 ros::param gebruiken om parameters in te stellen

De functie ros::param::set wordt gebruikt om parameters in te stellen. Het eerste argument van de functie is de parameternaam en het tweede is de parameterwaarde. Als de parameternaam begint met /, is het een globale parameter. Als hij begint met ~, is het een privé-parameter. Anders is het een relatieve parameter.

Voorbeeld:

cpp
ros::param::set("/set_A", 100); // Global, independent of namespace and node name
ros::param::set("set_B", 100);  // Relative, dependent on namespace
ros::param::set("~set_C", 100); // Private, dependent on namespace and node name

Aangenomen dat de namespace xxx is en de nodenaam yyy, zou het controleren van de parameters met rosparam list het volgende tonen:

plaintext
/set_A
/xxx/set_B
/xxx/yyy/set_C

ros::NodeHandle gebruiken om parameters in te stellen

Om parameters in te stellen met ros::NodeHandle, maakt u eerst een NodeHandle-object en roept u vervolgens de methode setParam aan. Als de parameternaam begint met /, is hij globaal. Als hij niet begint met /, hangt het af van hoe het NodeHandle-object is gemaakt of hij relatief of privé is.

Voorbeeld:

cpp
ros::NodeHandle nh;
nh.setParam("/nh_A", 100); // Global, independent of namespace and node name

nh.setParam("nh_B", 100);  // Relative, dependent on namespace

ros::NodeHandle nh_private("~");
nh_private.setParam("nh_C", 100); // Private, dependent on namespace and node name

Aangenomen dat de namespace xxx is en de nodenaam yyy, zou het controleren van de parameters met rosparam list het volgende tonen:

plaintext
/nh_A
/xxx/nh_B
/xxx/yyy/nh_C

2. Python-implementatie

In Python is het instellen van parameters iets eenvoudiger dan in C++. De functie rospy.set_param wordt gebruikt om parameters in te stellen. Het eerste argument is de parameternaam en het tweede is de waarde. Net als in C++ is een parameter globaal als de naam begint met /. Als hij begint met ~, is hij privé. Anders is hij relatief.

Voorbeeld:

python
rospy.set_param("/py_A", 100)  # Global, independent of namespace and node name
rospy.set_param("py_B", 100)   # Relative, dependent on namespace
rospy.set_param("~py_C", 100)  # Private, dependent on namespace and node name

Aangenomen dat de namespace xxx is en de nodenaam yyy, zou het controleren van de parameters met rosparam list het volgende tonen:

plaintext
/py_A
/xxx/py_B
/xxx/yyy/py_C