Conceptos básicos de programación de Robot CPP-03 Tipos de variables Tipos de variables

Conceptos básicos de programación de Robot CPP-02 Variables Variables

---

Generación de IA de texto completo.

---

C++

#include<iostream>

using namespace std;

main()
{
    int a=10,b=35; // 4 bytes
    cout<<"Value of a : "<<a<<" Address of a : "<<&a <<endl;
    cout<<"Value of b : "<<b<<" Address of b : "<<&b <<endl;

    short s=20; //2 bytes
    cout <<"Value of s : "<< s << endl;

    float f1=20.03; //4 bytes
    double d1=50.55416416; //8 bytes
    cout <<"Value of f1 : "<< f1 << endl;
    cout <<"Value of d1 : "<< d1 << endl;

    char c1='A';
    cout<<c1<<endl;

    string s1="Hello Tridib";
    cout<<s1<<endl;

    string s2="Welcome to CPP !";
    cout<<s2<<endl;

    string combineStrings=s1+", "+s2;
    cout<<combineStrings<<endl;

    bool b1=true; //Boolean is true or false. FALSE IS ALWAYS ZERO, EVERY OTHER NUMBER IS TRUE.
    cout<<b1<<endl;
    b1=1515;
    cout<<b1<<endl;
    b1=-445;
    cout<<b1<<endl;
    b1=0;
    cout<<b1<<endl;

    //Positive numbers or unsigned numbers. Increases the positive range.
    unsigned short int u1=60445;
    cout<< u1 <<endl;

    const string myname="Tridib";
    cout << myname << endl;

}

El código está escrito en C++ e incluye la declaración e inicialización de varios tipos de datos, y cómo usar coutdeclaraciones para imprimir los valores y direcciones de estas variables. El siguiente es un análisis detallado de cada línea:

Lo anterior es un análisis detallado de este código.

1. #include<iostream>: Una biblioteca que contiene flujos de entrada/salida. Esto permite que los programas utilicen funciones de entrada y salida.
2. using namespace std;: declarar utilizando stdun espacio de nombres. stdes la abreviatura estándar de la biblioteca estándar. De esta forma, podemos usar directamente los nombres en la biblioteca estándar sin escribir antes de cada nombre std::.
3. main(): La función principal del programa, todos los programas C++ se ejecutan desde aquí.
4. int a=10,b=35;: Declare dos variables enteras a y b e inicialícelas en 10 y 35.
5. cout<<"Value of a : "<<a<<" Address of a : "<<&a <<endl;: Use para coutimprimir "Valor de a:" y el valor de la variable a, y luego imprima "Dirección de a:" y la dirección de la variable a. &El operador se utiliza para obtener la dirección de memoria de una variable. endlSe utiliza para insertar nuevas filas.
6. cout<<"Value of b : "<<b<<" Address of b : "<<&b <<endl;: Similar al anterior, pero imprime el valor y la dirección de la variable b.
7. short s=20;: Declare una variable entera corta s e inicialícela a 20. Un corto suele ser de 2 bytes (16 bits) en la mayoría de los sistemas.
8. cout <<"Value of s : "<< s << endl;: Use para coutimprimir "Valor de s:" y el valor de la variable s.
9. float f1=20.03;: Declare una variable de punto flotante de precisión simple f1 e inicialícela a 20.03. Un flotante suele tener 4 bytes (32 bits) en la mayoría de los sistemas.
10. double d1=50.55416416;: Declare una variable de coma flotante de precisión doble d1 e inicialícela en 50.55416416. Un doble suele tener 8 bytes (64 bits) en la mayoría de los sistemas.
11. cout <<"Value of f1 : "<< f1 << endl;: Use para coutimprimir "Valor de f1:" y el valor de la variable f1.
12. cout <<"Value of d1 : "<< d1 << endl;: Use para coutimprimir "Valor de d1:" y el valor de la variable d1.
13. char c1='A';: Declare una variable de carácter c1 e inicialícela en 'A'.
14. cout<<c1<<endl;: Se utiliza para coutimprimir el valor de la variable c1, que es el carácter 'A'.
15. string s1="Hello Tridib";: Declare una variable de cadena s1 e inicialícela en "Hello Tridib".
16. cout<<s1<<endl;: se utiliza para coutimprimir el valor de la variable s1, que es "Hello Tridib".
17. string s2="Welcome to CPP !";: Declare otra variable de cadena s2 e inicialícela en "¡Bienvenido a CPP!".
18. cout<<s2<<endl;: Use para coutimprimir el valor de la variable s2, que es "¡Bienvenido a CPP!".
19. string combineStrings=s1+", "+s2;: Una s1 y s2 para crear una nueva cadena combineStrings.
20. cout<<combineStrings<<endl;: Utilice coutel valor de la variable de impresión combineStrings, que es "Hola Tridib, ¡Bienvenido a CPP!".
21. bool b1=true;: Declare una variable booleana b1 e inicialícela en verdadero. En C++, el valor de tipo booleano solo puede ser verdadero o falso.
22. cout<<b1<<endl;: Se usa para coutimprimir el valor de la variable b1, que es verdadero. En C++, los valores booleanos se convierten automáticamente en cadenas "verdadero" o "falso" cuando se emiten.
23. b1=1515;: Cambia el valor de la variable b1 al entero 1515. En C++, el valor del tipo booleano también puede ser 0 o cualquier número entero distinto de 0.
24. cout<<b1<<endl;: se utiliza coutpara imprimir el valor de la variable b1, ya que un entero distinto de cero se considerará verdadero, por lo que la salida aquí es verdadera.
25. b1=-445;: Cambia el valor de la variable b1 a -445.
26. cout<<b1<<endl;: use coutel valor de la variable de impresión b1, ya que los enteros distintos de cero se considerarán verdaderos, así que aquí

    La salida es verdadera.

27.  b1=0;: Cambia el valor de la variable b1 a 0.

28. cout<<b1<<endl;: Úselo para coutimprimir el valor de la variable b1, ya que el valor de tipo booleano solo puede ser verdadero o falso, por lo que la salida aquí es falsa.
29. unsigned short int u1=60445;: Declare una variable entera corta sin signo u1 e inicialícela en 60445. En la mayoría de los sistemas, un corto sin firmar suele ser de 2 bytes (16 bits).
30. cout<< u1 <<endl;: Se usa para coutimprimir el valor de la variable u1. Dado que es un tipo sin signo, se pueden generar números enteros superiores a 255.
31. const string myname="Tridib";: Declare una variable de cadena constante myname e inicialícela a "Tridib". La palabra clave const indica que el valor de la variable no se puede modificar.
32. cout << myname << endl;: Use para coutimprimir el valor de la variable myname, que es "Tridib".

C++ es un lenguaje de programación multiparadigma que admite múltiples tipos de variables. Los siguientes son los principales tipos de variables y sus descripciones en C++:

1. tipo básico

   • Tipos enteros : estos tipos se utilizan para almacenar valores enteros. Ambos tipos firmados y sin firmar.

     • int: normalmente de 32 bits, pero el tamaño puede variar según la plataforma.
     • short: Generalmente 16 bits.
     • long: por lo general, 32 bits o 64 bits, el tamaño puede variar según la plataforma.
     • long long: Típicamente de 64 bits, el tamaño puede variar según la plataforma.

   • Tipos de punto flotante : Estos tipos se utilizan para almacenar valores con punto decimal.

     • float: Precisión simple, generalmente 32 bits.
     • double: Doble precisión, normalmente 64 bits.

   • Tipos de caracteres : estos tipos se utilizan para almacenar un solo carácter o un valor ASCII.

     • char: firmado o sin firmar, generalmente 8 bits.

   • Tipo booleano : bool, utilizado para almacenar valores lógicos, puede ser trueORed false.

2. tipo compuesto

   • Array : Se utiliza para almacenar múltiples elementos del mismo tipo.
   • Cadena : una matriz de caracteres, utilizada para almacenar varios caracteres.
   • Estructura : se utiliza para combinar múltiples variables de diferentes tipos.
   • Unión : se utiliza para compartir múltiples variables de diferentes tipos de datos en la memoria.

3. tipo de puntero

   • int *p;: Define un puntero a un entero.
   • double *dp;: define un puntero a un número de punto flotante de precisión doble.
   • char *cp;: Define un puntero a un carácter.

4. tipo de referencia

   • int &ref;: Define una referencia a una variable entera. Una referencia y la variable a la que se refiere son la misma entidad en la memoria.

5. tipo enumerado

   • enum color { red, green, blue };: define un tipo enumerado denominado color que contiene tres valores posibles: rojo, verde y azul.

6. tipo personalizado

   • Clases : defina tipos de datos y métodos personalizados. Una clase es un tipo de datos definido por el usuario que puede contener atributos (variables) y métodos (funciones).

7. tipo especial

   • void: indica ningún tipo, a menudo se usa para el tipo de valor de retorno de una función, como void func()indicar que la función no tiene valor de retorno.
   • const: Indica una constante, una vez dado un valor no se puede cambiar. Por ejemplo const int a = 10;, el valor de a no se puede cambiar.
   • volatile: Indica variable, es decir, el programa no puede predecir que el valor de la variable cambiará en cualquier momento. Por ejemplo, los valores de registros de hardware, procesos en ejecución, etc.

8. Más extensiones para tipos compuestos (como matrices, punteros, referencias, etc.):

   • Matriz de punteros : Los elementos de la matriz son de tipo puntero. Por ejemplo, int *arr[5]se define una matriz que contiene 5 punteros a números enteros.
   • Puntero a puntero : Por ejemplo, int **pp;se define un puntero a puntero, que puede apuntar a una variable de tipo entero.
   • Matriz de referencia : por ejemplo, int &arr[5]se define una matriz que contiene 5 referencias enteras. Cada referencia es un alias para el elemento de matriz al que se refiere.

9. Puntero de funciónint (*fp)(int) : se define un puntero a una función, por ejemplo, un puntero de función que acepta un parámetro entero y devuelve un entero.

10. Punteros inteligentes : C++ 11 introduce punteros inteligentes para ayudar a administrar la memoria asignada dinámicamente. Un puntero inteligente es una clase que administra automáticamente la memoria asignada dinámicamente de manera segura. Estos son algunos tipos de punteros inteligentes:

    • std::unique_ptr<T>: este tipo de puntero elimina automáticamente su propiedad cuando sale del alcance. Solo puede apuntar a un objeto y garantiza que el objeto al que apunta tiene un propietario en cualquier momento.
    • std::shared_ptr<T>: este tipo de puntero permite que varios punteros inteligentes compartan el mismo objeto. Cuando el último puntero inteligente queda fuera del alcance o se reinicia, elimina automáticamente el objeto al que apunta.
    • std::weak_ptr<T>: este tipo de puntero también apunta a un objeto compartido, pero no aumenta el número de referencias del objeto. La destrucción del objeto se verá cuando el último shared_ptrquede fuera del alcance o se reinicie .weak_ptr

Estos son los principales tipos de variables en C++. Opcionalmente, también se pueden crear estructuras y tipos personalizados para satisfacer necesidades de programación específicas.

C++14 introduce algunos nuevos tipos de variables que se ampliaron tanto en C++11 como en C++17. Los siguientes son algunos de los nuevos tipos de variables introducidos en C++14:

1. Tipos atómicos (Atomic Types) : estos tipos se definen en el archivo de encabezado <atomic> y se utilizan para representar valores que se pueden manipular individualmente sin causar que otros hilos se bloqueen. Los tipos atómicos incluyen tipos enteros, de coma flotante y punteros.

   • atomic<T>: define el tipo básico de una operación atómica. Una operación atómica es una operación realizada en un solo subproceso que modifica datos sin interferencia de otros subprocesos.
   • atomic_flag: define un indicador atómico que se puede utilizar para implementar operaciones booleanas atómicas simples.

2. Inicialización de arreglos : C++14 introduce un nuevo método de inicialización de arreglos que permite {}la inicialización mediante llaves. Por ejemplo:

cpp复制代码

int arr[] = {1, 2, 3, 4, 5};

1. Captura lambda genérica : C++14 introduce la captura lambda genérica, que permite capturar variables ya sea que estén dentro del alcance o no. Por ejemplo:

cpp复制代码

auto lambda = [captured_var = some_global_var](){ /* Use captured_var */ };

1. Referencias Rvalue : las referencias Rvalue se amplían aún más para que sean más fáciles de usar y más flexibles. C ++ 14 presenta std::movey std::forwardfunciona para la semántica de movimiento y el reenvío perfecto.
2. Deducción de tipos : C++14 introduce algunas reglas de deducción de tipos nuevas, incluida la extracción de parámetros de tipos de funciones y matrices.
3. Compatibilidad con Unicode : C++14 presenta una compatibilidad Unicode más completa, incluidos nuevos tipos de caracteres y funciones.
4. Almacenamiento local de subprocesos : C ++ 14 introduce almacenamiento local de subprocesos, que permite almacenar una copia separada de variables para cada subproceso.
5. Literales binarios : C ++ 14 introduce nuevos literales binarios, incluidos números binarios enteros y números binarios de punto flotante.
6. Mostrar números de coma flotante para literales : C++14 permite el uso de mostrar números de coma flotante en literales, por ejemplo, 0x1p+2npara representar un número hexadecimal de coma flotante.

Estos son algunos de los principales tipos de variables y funciones introducidos por C++14. Estas características mejoran el poder expresivo y el rendimiento del lenguaje y brindan más flexibilidad y control.

C++20 presenta varios tipos de variables y funciones nuevas que amplían aún más el poder expresivo y el rendimiento del lenguaje. Los siguientes son algunos de los nuevos tipos de variables y funciones introducidos en C++20:

1. Conceptos : los conceptos son características del lenguaje que especifican las condiciones que debe satisfacer un tipo. Los conceptos se pueden utilizar para restringir los tipos de parámetros de plantilla para garantizar que los tipos se ajusten a los requisitos específicos cuando se crea una instancia de la plantilla. Esto ayuda a mejorar la legibilidad y la mantenibilidad del código.

cpp复制代码

	template <typename T> concept bool C() { return requires (T t) { t++; }; }
	template <C T> void f(T t) { ++t; }

1. Enlace estructurado : C ++ 20 introduce el enlace estructurado, que permite que el valor de una expresión se asigne directamente a múltiples variables. Esto lo hace más conveniente cuando se desestructuran arreglos, tuplas u otros tipos de compuestos.

cpp复制代码

	int a = 1, b = 2;
	auto [c, d] = a + b; // c = 3, d = 3

1. if constexpr : C++20 introdujo if constexprla declaración, que permite elegir condicionalmente diferentes rutas de código en tiempo de compilación. Esto es útil para compilación condicional y despacho estático en tiempo de compilación.

cpp复制代码

	template <typename T> void f(T value) {
	if constexpr (std::is_integral_v<T>) {
	// 处理整数类型
	} else if constexpr (std::is_floating_point_v<T>) {
	// 处理浮点数类型
	}
	}

1. Comparación de tres vías (Comparación de tres vías) : C++20 introduce un operador de comparación de tres vías <=>para realizar operaciones basadas en la comparación. Esto se puede usar para implementar operaciones de comparación para tipos personalizados.
2. Alias ​​de plantilla (Template Aliases) : C++20 introduce alias de plantilla, lo que permite el uso de alias para simplificar la declaración y el uso de plantillas.
3. Expresiones de pliegue : C++20 introduce expresiones de pliegue, que permiten la evaluación recursiva al expandir operadores binarios o ternarios. Esto es útil para implementar funciones de orden superior y algoritmos genéricos.
4. Espacios de nombres anidados (Nested Namespaces) : C++20 permite definir otro espacio de nombres dentro de un espacio de nombres para organizar mejor el código.
5. Nombre repetido contextual : C++20 permite que los nombres se repitan en contextos específicos, lo que ayuda a mejorar la legibilidad del código.
6. Módulos : C++20 introduce módulos, una forma de dividir el código en unidades lógicas para mejorar la velocidad de compilación y la organización del código. Los módulos se pueden usar para implementar la encapsulación y la reutilización de funciones o bibliotecas específicas.
7. Concept Tools (Concept Tools) : C++20 proporciona un conjunto de herramientas para definir y manipular conceptos. Esto ayuda a mejorar la legibilidad y la mantenibilidad del código.

Estos son algunos de los principales tipos de variables y funciones introducidos por C++20. Estas funciones mejoran aún más la expresividad y el rendimiento del lenguaje y proporcionan más flexibilidad y control.

---

arduino

#include <avr/pgmspace.h>  
  
void setup() {  
  Serial.begin(9600);  
  
  int a = 10;  
  Serial.print("Value of a : ");  
  Serial.print(a);  
  Serial.print(" Address of a : ");  
  Serial.println(&a);  
  
  short s = 20;  
  Serial.print("Value of s : ");  
  Serial.println(s);  
  
  float f1 = 20.03;  
  Serial.print("Value of f1 : ");  
  Serial.print(f1);  
  Serial.println();  
  
  double d1 = 50.55416416;  
  Serial.print("Value of d1 : ");  
  Serial.println(d1);  
  
  char c1 = 'A';  
  Serial.print(c1);  
  Serial.println();  
  
  const char* s1 = "Hello Tridib";  
  Serial.println(s1);  
  
  const char* s2 = "Welcome to CPP !";  
  Serial.println(s2);  
  
  const char* combineStrings = pgm_read_word(&combineStrings); //pgm_read_word(&combineStrings) is used to get the address of the combineStrings variable in flash memory space and is not related to the original code  
  Serial.println(combineStrings);  
  
  bool b1 = true;  
  Serial.println(b1);  
  b1 = 1515;  
  Serial.println(b1);  
  b1 = -445;  
  Serial.println(b1);  
  b1 = 0;  
  Serial.println(b1);  
  
  unsigned short int u1 = 60445;  
  Serial.println(u1);  
}  
  
void loop() {  
  // put your main code here, to run repeatedly:  
}

Arduino IDE utiliza tipos de variables de C++, por lo que es compatible con todos los tipos de variables comunes de C++. Los siguientes son los tipos de variables de C++ comúnmente utilizados en el IDE de Arduino:

1. tipo básico

   • int: se utiliza para representar valores enteros, normalmente de 16 bits.
   • unsigned int: se utiliza para representar valores enteros sin signo, normalmente de 16 bits.
   • long: se utiliza para representar valores enteros largos, normalmente de 32 bits.
   • unsigned long: se utiliza para representar un valor entero largo sin signo, normalmente de 32 bits.
   • char: se utiliza para representar valores de caracteres, normalmente de 8 bits.
   • bool: se utiliza para representar un valor booleano, que puede ser trueORed false.
   • float: se utiliza para representar valores de punto flotante de precisión simple, normalmente de 32 bits.
   • double: se utiliza para representar valores de punto flotante de doble precisión, generalmente de 64 bits.

2. tipo de puntero

   • int *p;: Define un puntero a un entero.
   • char *str;: Define un puntero a una matriz de caracteres.

3. tipo de matriz

   • int arr[10];: Define una matriz de 10 enteros.
   • char str[] = "Hello";: Define una matriz de caracteres que contiene la cadena "Hola".

4. tipo de estructura

   • struct MyStruct { int id; char name[20]; };: defina una estructura denominada MyStruct, que contiene un id de variable de miembro entero y un nombre de variable de miembro de matriz de caracteres.

5. Tipo de unión

   • union MyUnion { int id; char name[20]; };: defina una unión denominada MyUnion, que contiene un id de variable de miembro entero y un nombre de variable de miembro de matriz de caracteres.

6. tipo de función

   • int myFunction(int arg1, char arg2);: defina una función denominada myFunction, acepte un parámetro entero arg1 y un parámetro de carácter arg2 y devuelva un valor entero.

7. tipo personalizado

   • typedef int MyInt;: Defina un nuevo alias de tipo MyInt, equivalente al tipo int.

8. tipo enumerado

   • enum MyEnum { RED, BLUE, GREEN };: define un tipo enumerado llamado MyEnum con tres valores posibles: ROJO, AZUL y VERDE.

9. conversión de tipos

   • Conversión automática de tipos: al asignar un valor de un tipo a una variable de otro tipo, el compilador realizará automáticamente la conversión de tipos. Por ejemplo, al asignar un valor entero a una variable de punto flotante, el compilador convierte el valor entero en un número de punto flotante.
   • Casting: use operadores de conversión para convertir un valor de un tipo a otro. Por ejemplo, (float) xconvierta x en un tipo flotante.

10. Constantes y expresiones constantes

    • Constante: use la palabra clave const para definir una constante cuyo valor no se puede cambiar durante la ejecución del programa. Por ejemplo, const int kConstantValue = 42;
    • Expresiones constantes: defina expresiones constantes utilizando inicializadores constantes y literales. Una expresión constante debe ser una expresión cuyo resultado se pueda evaluar en tiempo de compilación y no puede contener variables ni llamadas a funciones. Por ejemplo, const int kExpresiónConstante = 4 * 7; es una expresión constante, pero const int kExpresiónVariable = k + 1; no es una expresión constante porque el valor de k no se puede determinar en tiempo de compilación.

Estos son los tipos de variables de C++ comúnmente utilizados y los conceptos relacionados en el IDE de Arduino. Comprender estos tipos y conceptos de variables es muy importante para escribir programas Arduino.

---

ROS1

¿Es factible la generación de IA? ? ?

#include <ros/ros.h>  
#include <std_msgs/String.h>  
  
int main(int argc, char **argv)  
{  
    ros::init(argc, argv, "my_node");  
    ros::NodeHandle nh;  
  
    int a=10,b=35; // 4 bytes  
    ros::console::cout << "Value of a : " << a << " Address of a : " << &a << ros::console::endl;  
    ros::console::cout << "Value of b : " << b << " Address of b : " << &b << ros::console::endl;  
  
    short s=20; //2 bytes  
    ros::console::cout << "Value of s : " << s << ros::console::endl;  
  
    float f1=20.03; //4 bytes  
    ros::console::cout << "Value of f1 : " << f1 << ros::console::endl;  
  
    double d1=50.55416416; //8 bytes  
    ros::console::cout << "Value of d1 : " << d1 << ros::console::endl;  
  
    int c1 = 65;  
    ros::console::cout << c1 << ros::console::endl;  
  
    std_msgs::String s1;  
    s1.data = "Hello Tridib";  
    ros::console::cout << s1.data << ros::console::endl;  
  
    std_msgs::String s2;  
    s2.data = "Welcome to CPP !";  
    ros::console::cout << s2.data << ros::console::endl;  
  
    // string concatenation not supported in ROS  
    // you can use roscpp'sRosOutSignal to achieve this easily.  
    // RosOutSignal().outStr(s1.data + ", " + s2.data);   
    // instead of the line above you can do:  
    std_msgs::String combineStrings;  
    combineStrings.data = s1.data + ", " + s2.data;  
    ros::console::cout << combineStrings.data << ros::console::endl;  
  
    bool b1=true; //Boolean is true or false. FALSE IS ALWAYS ZERO, EVERY OTHER NUMBER IS TRUE.  
    ros::console::cout << b1 << ros::console::endl;  
    b1=1515;  
    ros::console::cout << b1 << ros::console::endl;  
    b1=-445;  
    ros::console::cout << b1 << ros::console::endl;  
    b1=0;  
    ros::console::cout << b1 << ros::console::endl;  
  
    //Positive numbers or unsigned numbers. Increases the positive range.  
    unsigned short int u1=60445;  
    ros::console::cout << u1 << ros::console::endl;  
  
    // const string myname="Tridib"; is not supported in ROS, you should use a string_view instead. (not implemented in roscpp at the time of writing)  
}

ROS1 Noetic es una versión de ROS1 que utiliza C++ como lenguaje de programación principal. En ROS1 Noetic, los tipos de variables comunes de C++ incluyen lo siguiente:

1. Tipos básicos : Igual que el C++ estándar, incluidos int, float, double, char, etc.
2. Tipo de puntero inteligente : ROS1 Noetic utiliza principalmente std::shared_ptrdos std::unique_ptrtipos de puntero inteligente para gestionar automáticamente el ciclo de vida de los recursos.
3. Tipo de función de devolución de llamada : ROS1 Noetic proporciona tipos de funciones de devolución de llamada específicos de ROS1, como boost::functiony boost::slot, para implementar mecanismos de devolución de llamada basados ​​en eventos.
4. Espacio de nombres : ROS1 Noetic utiliza varios espacios de nombres, como ros, std_msgs, sensor_msgsetc., para organizar y administrar el código relacionado con ROS y los tipos de mensajes.
5. Tipo de mensaje : ROS1 Noetic utiliza tipos de mensajes específicos, como std_msgs::String, sensor_msgs::Imageetc., para la comunicación entre nodos en el sistema ROS. Estos tipos de mensajes generalmente se definen en la especificación de mensajes ROS1.
6. Tipos de servicios : ROS1 Noetic utiliza tipos de servicios específicos, como ros::ServiceServery ros::ServiceResponse, para implementar llamadas de servicio en el sistema ROS. Estos tipos de servicio se definen en la especificación de servicio ROS1.
7. Tipos de acción : ROS1 Noetic utiliza tipos de acción específicos, como actionlib::SimpleActionClienty actionlib::SimpleGoal, para el control de comportamiento complejo en sistemas ROS. Estos tipos de acción se definen en la especificación de acción ROS1.

Además de los tipos de variables anteriores, ROS1 Noetic también proporciona muchas otras herramientas y bibliotecas para el control de robots, procesamiento de datos de sensores, visualización y otras funciones.

---