Minor updates

Author: pablogs9

_docs/tutorials/programming_rcl_rclc/micro-ROS/micro-ROS.md

@@ -5,18 +5,21 @@ permalink: /docs/tutorials/programming_rcl_rclc/micro-ROS/
 
 // TODO
 
-## <a name="sub"/>Time sync
+- [Time sync](#time-sync)
+- [Ping agent](#ping-agent)
 
-```C
+## Time sync
+
+```c
 bool rmw_uros_epoch_synchronized();
 int64_t rmw_uros_epoch_millis();
 int64_t rmw_uros_epoch_nanos();
 rmw_ret_t rmw_uros_sync_session(const int timeout_ms);
 ```
 
-## <a name="sub"/>Ping agent
+## Ping agent
 
-```C
+```c
 rmw_ret_t rmw_uros_ping_agent(const int timeout_ms, const uint8_t attempts);
 ```
 
@@ -25,7 +28,7 @@ rmw_ret_t rmw_uros_ping_agent(const int timeout_ms, const uint8_t attempts);
 - Discovery ??
 
 - Continous serialization ??
--```C
+-```c
 void rmw_uros_set_continous_serialization_callbacks(
 rmw_publisher_t * publisher,
 rmw_uros_continous_serialization_size size_cb,

_docs/tutorials/programming_rcl_rclc/node/node.md

@@ -3,13 +3,17 @@ title: Nodes
 permalink: /docs/tutorials/programming_rcl_rclc/node/
 ---
 
-ROS 2 nodes are the main participants on ROS2 ecosystem. They will communicate between each other using publishers, subscriptions, services, ... Further information about ROS 2 nodes can be found [here](https://docs.ros.org/en/galactic/Tutorials/Understanding-ROS2-Nodes.html)
+ROS 2 nodes are the main participants on ROS 2 ecosystem. They will communicate between each other using publishers, subscriptions, services, etc. Further information about ROS 2 nodes can be found [here](https://docs.ros.org/en/galactic/Tutorials/Understanding-ROS2-Nodes.html)
 
 // TODO: explain general micro-ROS initialization (allocator and support). Where?
-## <a name="init_node"/>Initialization
+
+- [Initialization](#initialization)
+  - [Cleaning Up](#cleaning-up)
+
+## Initialization
 
 - Create a node with default configuration:
-  ```C
+  ```c
   // Initialize micro-ROS allocator
   rcl_allocator_t allocator = rcl_get_default_allocator();
 
@@ -33,13 +37,14 @@ ROS 2 nodes are the main participants on ROS2 ecosystem. They will communicate b
   ```
 
 - Create a node with custom options:
+
   // TODO: explain possible options
 
   The configuration of the node will also be applied to its future elements (Publishers, subscribers, services, ...).The API used to customize the node options differs between ROS2 distributions:
 
   Foxy: The `rcl_node_options_t` is used to configure the node
 
-  ```C
+  ```c
   // Initialize allocator and support objects
   ...
 
@@ -51,37 +56,37 @@ ROS 2 nodes are the main participants on ROS2 ecosystem. They will communicate b
   const char * namespace = "test_namespace";
 
   // Get default node options and modify them
-	rcl_node_options_t node_ops = rcl_node_get_default_options();
+  rcl_node_options_t node_ops = rcl_node_get_default_options();
 
   // Set node ROS domain ID to 10
-	node_ops.domain_id = (size_t)(10);
+  node_ops.domain_id = (size_t)(10);
 
   // Init node with custom options
-	rc = rclc_node_init_with_options(&node, node_name, namespace, &support, &node_ops);
+  rc = rclc_node_init_with_options(&node, node_name, namespace, &support, &node_ops);
 
   if (rc != RCL_RET_OK) {
     ... // Handle error
     return -1;
   }
   ```
-  
+
   Galactic: In this case, the node options are configured on the `rclc_support_t` object with a custom API
 
-  ```C
+  ```c
   // Initialize micro-ROS allocator
   rcl_allocator_t allocator = rcl_get_default_allocator();
 
   // Initialize and modify options (Set DOMAIN ID to 10)
-	rcl_init_options_t init_options = rcl_get_zero_initialized_init_options();
-	rcl_init_options_init(&init_options, allocator);
-	rcl_init_options_set_domain_id(&init_options, 10);
+  rcl_init_options_t init_options = rcl_get_zero_initialized_init_options();
+  rcl_init_options_init(&init_options, allocator);
+  rcl_init_options_set_domain_id(&init_options, 10);
 
   // Initialize rclc support object with custom options
   rclc_support_t support;
-	rclc_support_init_with_options(&support, 0, NULL, &init_options, &allocator);
+  rclc_support_init_with_options(&support, 0, NULL, &init_options, &allocator);
 
   // Create node object
-	rcl_node_t node;
+  rcl_node_t node;
   const char * node_name = "test_node";
 
   // Node namespace (Can remain empty "")
@@ -96,11 +101,11 @@ ROS 2 nodes are the main participants on ROS2 ecosystem. They will communicate b
   }
   ```
 
-### <a name="node_end"/>Cleaning Up
+### Cleaning Up
 
 To destroy a initialized node all entities owned by the node (Publishers, subscribers, services, ...) have to be destroyed before the node itself:
 
-```C
+```c
 // Destroy created entities (Example)
 rcl_publisher_fini(&publisher, &node);
 ...

_docs/tutorials/programming_rcl_rclc/overview/index.md

@@ -5,7 +5,9 @@ redirect_from:
   - /docs/tutorials/programming_rcl_rclc/
 ---
 
-In this tutorial, you'll learn the basics of the micro-ROS C API. The major concepts (publishers, subscriptions, services, timers, ...) are identical with ROS 2. They even rely on the *same* implementation, as the micro-ROS C API is based on the ROS 2 client support library (rcl), enriched with a set of convenience functions by the package [rclc](https://github.com/ros2/rclc/). That is, rclc does not add a new layer of types on top of rcl (like rclcpp and rclpy do) but only provides functions that ease the programming with the rcl types. New types are introduced only for concepts that are missing in rcl, such as the concept of an executor.
+In this section, you'll learn the basics of the micro-ROS C API: **rclc**.
+
+The major concepts (publishers, subscriptions, services, timers, ...) are identical with ROS 2. They even rely on the *same* implementation, as the micro-ROS C API is based on the ROS 2 client support library (rcl), enriched with a set of convenience functions by the package [rclc](https://github.com/ros2/rclc/). That is, rclc does not add a new layer of types on top of rcl (like rclcpp and rclpy do) but only provides functions that ease the programming with the rcl types. New types are introduced only for concepts that are missing in rcl, such as the concept of an executor.
 
 * [**Nodes**](../node/)
 * [**Publishers and Subscriptions**](../pub_sub/)

_docs/tutorials/programming_rcl_rclc/parameters/parameters.md

@@ -9,10 +9,16 @@ Ready to use code related to this tutorial can be found in [`rclc/rclc_examples/
 
 Note: micro-ROS parameter server is only supported on ROS2 galactic distribution
 
-## <a name="parameters_init"/>Initialization
+- [Initialization](#initialization)
+- [Memory requirements](#memory-requirements)
+- [Callback](#callback)
+- [Add a parameter](#add-a-parameter)
+- [Cleaning up](#cleaning-up)
+
+## Initialization
 
 - Default initialization:
-    ```C
+    ```c
     // Parameter server object
     rclc_parameter_server_t param_server;
 
@@ -27,12 +33,14 @@ Note: micro-ROS parameter server is only supported on ROS2 galactic distribution
 
     // TODO: explain options
 - Custom options:
-    ```C
+    ```c
     // Parameter server object
     rclc_parameter_server_t param_server;
 
     // Define parameter server options
-    const rclc_parameter_options_t options = { .notify_changed_over_dds = true, .max_params = 4 };
+    const rclc_parameter_options_t options = {
+        .notify_changed_over_dds = true,
+        .max_params = 4 };
 
     // Initialize parameter server with configured options
     rcl_ret_t rc = rclc_parameter_server_init_with_option(&param_server, &node, &options);
@@ -43,10 +51,10 @@ Note: micro-ROS parameter server is only supported on ROS2 galactic distribution
     }
     ```
 
-## <a name="parameters_init"/>Memory requirements
+## Memory requirements
 The parameter server uses 4 services and an optional publisher, this needs to be taken into account on the `rmw-microxredds` package memory configuration:
 
-```C
+```json
 # colcon.meta example with memory requirements to use a parameter server
 {
     "names": {
@@ -65,19 +73,21 @@ The parameter server uses 4 services and an optional publisher, this needs to be
 
 On runtime, the variable `RCLC_PARAMETER_EXECUTOR_HANDLES_NUMBER` defines the RCLC executor handles required for a parameter server:
 
-```C
+```c
 // Executor init example with the minimum RCLC executor handles required
 rclc_executor_t executor = rclc_executor_get_zero_initialized_executor();
-rc = rclc_executor_init(&executor, &support.context, RCLC_PARAMETER_EXECUTOR_HANDLES_NUMBER, &allocator);
+rc = rclc_executor_init(
+    &executor, &support.context,
+    RCLC_PARAMETER_EXECUTOR_HANDLES_NUMBER, &allocator);
 ```
-  
-## <a name="parameters_callback"/>Callback
+
+## Callback
 
 When adding the parameter server to the executor, a callback can be configured.
 This callback will be executed after a parameter value is modified.
 
 A pointer to the changed parameter is passed as first and only argument. Example:
-```C
+```c
 void on_parameter_changed(Parameter * param)
 {
     // Get parameter name
@@ -104,24 +114,24 @@ void on_parameter_changed(Parameter * param)
 }
 ```
 Once the parameter server and the executor are initialized, the parameter server must be added to the executor in order to accept parameters commands from ROS2:
-```C
+```c
 // Add parameter server to executor including defined callback
 rc = rclc_executor_add_parameter_server(&executor, &param_server, on_parameter_changed);
 ```
 
 Note that this callback is optional as its just an event information for the user. To use the parameter server without a callback:
-```C
+```c
 // Add parameter server to executor without callback
 rc = rclc_executor_add_parameter_server(&executor, &param_server, NULL);
 ```
 
 
-## <a name="parameters_add"/>Add a parameter
+## Add a parameter
 
 // TODO: improve explanation of types
 
 - Bool parameter
-```C
+```c
 const char * parameter_name = "parameter_bool";
 bool param_value = true;
 
@@ -141,7 +151,7 @@ if (RCL_RET_OK != rc) {
 ```
 
 - Integer parameter
-```C
+```c
 const char * parameter_name = "parameter_int";
 int param_value = 100;
 
@@ -156,7 +166,7 @@ rc = rclc_parameter_get_int(&param_server, parameter_name, &param_value);
 ```
 
 - Double parameter
-```C
+```c
 const char * parameter_name = "parameter_double";
 double param_value = 0.15;
 
@@ -170,11 +180,11 @@ rc = rclc_parameter_set_double(&param_server, parameter_name, param_value);
 rc = rclc_parameter_get_double(&param_server, parameter_name, &param_value);
 ```
 
-## <a name="parameters_end"/>Cleaning up
+## Cleaning up
 
 To destroy an initialized parameter server:
 
-```C
+```c
 // Delete parameter server
 rclc_parameter_server_fini(&param_server, &node);
 ```