Al insertar un puerto USB con identificación ttyUSB0

Verificación de la ruta del dispositivo ttyUSB0

1. Ejecutar en terminal: udevadm info -q path -n /dev/ttyUSB0

udevadm info -q path -n /dev/ttyUSB0

Resultado: /devices/platform/3610000.xhci/usb1/1-2/1-2.4/1-2.4.4/1-2.4.4.2/1-2.4.4.2:1.0/ttyUSB0/tty/ttyUSB0

Esta ruta se utiliza para coincidir exactamente con la ruta del dispositivo en el kernel. Este camino identifica de manera única el dispositivo en el árbol de dispositivos de udev. Luego, en /etc/udev/rules.d/99-usb.rules, configurar:

SUBSYSTEM=="tty", KERNELS=="1-2.4.4.4.2:1.2", SYMLINK+="ttyUSB_MCU" Esto crea un alias para ttyUSB0 llamado ttyUSB_MCU

Bloqueo de interfaces:

KERNELS=="1-2.4.4.4.1.2", ATTR{authorized}="0"

• El atributo authorized controla si el dispositivo está autorizado para ser utilizado por el sistema. Cuando se establece en 0, el dispositivo no será reconocido o utilizado hasta que el atributo se cambie a 1. Esto funciona como un mecanismo de seguridad.

2. Para encontrar archivos que consumen recursos, se puede usar el comando find con otras opciones. Para buscar archivos mayores de 1000MB en el directorio actual y subdirectorios:

find . -type f -size +1000M

Para ver el uso del disco:

sudo du -sh /* 2>/dev/null
sudo du -sh /ruta/al/directorio

Para eliminar archivos grandes:

sudo rm -rf /var/log/*.gz

3. Para ver cuánto espacio ocupa un directorio, como la carpeta "nav":

du -sh nav

4. Montaje de máquinas virtuales:

sudo mount -t vboxsf ubuntu_share /mnt/share

Donde ubuntu_share es el directorio en Windows y /mnt/share es el directorio en Ubuntu.

5. Acceso remoto:

sudo apt-get install sshpass

Script de ejemplo:

#!/bin/bash
sshpass -p unix_ai ssh unix_ai@192.168.15.26

Alternativa, configurar directamente en el explorador:

sftp://192.168.0.176/

6. Prueba de velocidad de red y conexión

Para probar el ancho de banda y velocidad de la red Ethernet:

sudo apt-get install iperf

Iniciar servidor:

sudo iperf -s

Iniciar cliente:

sudo iperf -c 192.168.1.xxx -i 5

Configuración de Mapeo de Puertos de Periféricos

Según el hardware (puerto serie, USB o ACM), configurar el archivo udev en /etc/udev/rules.d para vincular dispositivos STM32 y láser:

Primero, para el puerto serie virtual del dispositivo STM32, usar lsusb para ver los ID de Vendor y Product. Luego crear y configurar /etc/udev/rules.d/roborts.rules:

KERNEL=="ttyACM*", ATTRS{idVendor}=="0483", ATTRS{idProduct}=="5740", MODE:="0777", SYMLINK+="serial_sdk"

Configurar de manera similar para el láser. Luego recargar y reiniciar el servicio udev, que podría requerir desconectar y volver a conectar el dispositivo:

sudo service udev reload
sudo service udev restart

Para configurar múltiples cámaras del mismo modelo, el proceso es más complejo ya que los ID de Vandor y Product son idénticos. En este caso, se debe examinar cada cámara específicamente:

udevadm info --attribute-walk --name=/dev/video0

Generalmente, se puede usar el número de serie diferente como atributo para distinguir cada cámara:

SUBSYSTEM=="usb", ATTR{serial}=="68974689267119892", ATTR{idVendor}=="1871", ATTR{idProduct}=="0101", SYMLINK+="camara0"
SUBSYSTEM=="usb", ATTR{serial}=="12345698798725654", ATTR{idVendor}=="1871", ATTR{idProduct}=="0101", SYMLINK+="camara1"

Para cámaras económicas con el mismo número de serie, se puede usar el puerto físico del HUB para diferenciarlas:

SUBSYSTEM=="usb", KERNEL=="2-3", ATTR{idVendor}=="1871", ATTR{idProduct}=="0101", SYMLINK+="camara0"
SUBSYSTEM=="usb", KERNEL=="2-4", ATTR{idVendor}=="1871", ATTR{idProduct}=="0101", SYMLINK+="camara1"

Instalación de ROS2 con tutorial:

wget http://fishros.com/install -O fishros && . fishros

https://zhuanlan.zhihu.com/p/801531279

Control de Impedancia para Brazos Robóticos:

Configuración de ganancias para el control de impedancia articular:

// Rigidez
const std::array<double, 7> k_gains = {
    {600.0, 600.0, 600.0, 600.0, 250.0, 150.0, 50.0}}; // Los valores de rigidez determinan la reacción de la articulación al desplazamiento
// Amortiguamiento
const std::array<double, 7> d_gains = {
    {50.0, 50.0, 50.0, 50.0, 30.0, 25.0, 15.0}}; // Los valores de amortiguamiento determinan la reacción de la articulación a la velocidad

// Leer términos coriolis actuales del modelo
std::array<double, 7> coriolis = model.coriolis(state);

// Calcular comando de par a partir de la ley de control de impedancia articular
// Nótese: La respuesta a nuestra cinemática inversa en el espacio cartesiano siempre está en state.q_d con un retardo de un paso de tiempo
std::array<double, 7> tau_d_calculado;
for (size_t i = 0; i < 7; i++) {
    tau_d_calculado[i] = // Ganancia de posición + ganancia de velocidad + término coriolis
        k_gains[i] * (state.q_d[i] - state.q[i]) - d_gains[i] * state.dq[i] + coriolis[i];
}

std::array<double, 7> tau_d_real{};
for (size_t i = 0; i < 7; ++i) {
    tau_d_real[i] = print_data.tau_d_anterior[i] + print_data.gravedad[i]; // Par articular deseado real = par calculado en el ciclo anterior + término de compensación de gravedad
    tau_error[i] = tau_d_real[i] - print_data.robot_state.tau_J[i];   // Error de par = par deseado real - par medido en el estado actual
    error_rms += std::pow(tau_error[i], 2.0) / tau_error.size();        // Error cuadrático medio, representa el promedio de los errores de par en todas las articulaciones
}

Adición de Plugins en ROS2

El código no tiene función main, se registra como plugin:

#include <memory>
#include "rclcpp/rclcpp.hpp"
#include "std_msgs/msg/string.hpp"

namespace compos_
{
    using std::placeholders::_1;
    class NodoSuscriptor : public rclcpp::Node
    {
    public:
        // Modificar el constructor para aceptar parámetros NodeOptions
        NodoSuscriptor(const rclcpp::NodeOptions & opciones)
        : Node("nodo_suscriptor", opciones)  // Llamar al constructor de la clase base
        {
            // Contenido original del constructor
            suscripcion_ = this->create_subscription<std_msgs::msg::String>(
                "chatter", 
                10, 
                std::bind(&NodoSuscriptor