Controlador robótico ROS baseado em Matlab: 9 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:36

Desde criança sempre sonhei em ser o Homem de Ferro e ainda sou. O Homem de Ferro é um daqueles personagens que são realisticamente possíveis e, simplesmente, eu aspiro me tornar o Homem de Ferro algum dia, mesmo que as pessoas riam de mim ou digam que é impossível porque "só é impossível até que alguém o faça" -Arnold Schwarzenegger.

ROS é uma estrutura emergente usada para desenvolver sistemas complexos de robótica. Suas aplicações incluem: Sistema de Montagem Automatizada, Teleoperação, Braços Protéticos e Maquinários Pesados do setor industrial.

Pesquisadores e engenheiros aproveitam o ROS para desenvolver os protótipos, enquanto diferentes fornecedores o usam para criar seus produtos. Ele tem uma arquitetura complexa que o torna difícil de ser gerenciado por um manco. Usar o MATLAB para criar o link de interface com ROS é uma abordagem inovadora que pode ajudar pesquisadores, engenheiros e fornecedores no desenvolvimento de soluções mais robustas.

Portanto, este instrutivo é sobre como fazer um controlador robótico ROS baseado em Matlab, este será um dos poucos tutoriais sobre isso por aí e entre os poucos instrutíveis ROS. O objetivo deste projeto é projetar um controlador que possa controlar qualquer robô ROS conectado à sua rede. Então vamos começar!

créditos de edição de vídeo: Ammar Akher, em [email protected]

Suprimentos

Os seguintes componentes são necessários para o projeto:

(1) ROS PC / Robô

(2) Roteador

(3) PC com MATLAB (versão: 2014 ou superior)

Etapa 1: Configurando tudo

Para isso, estou usando o Ubuntu 16.04 para o meu linux pc e ros-kinetic, portanto, para evitar confusão, recomendo usar ros kinetic e ubuntu 16.04, pois tem o melhor suporte para ros-kinetic. Para obter mais informações sobre como instalar o ros kinetic, vá para https://wiki.ros.org/kinetic/Installation/Ubuntu. Para o MATLAB, você compra uma licença ou baixa uma versão de teste aqui.

Etapa 2: Compreendendo como o controlador funciona

Um PC executa o controlador robótico no MATLAB. O controlador obtém o endereço IP e a porta do ros pc / robô.

Um ros-topic é usado para a comunicação entre o controlador e o ros pc / robô, que também é considerado como entrada pelo controlador. O modem é necessário para criar uma LAN (rede local) e é o que atribui os endereços IP a todos os dispositivos conectados à sua rede. Portanto, o ros pc / robô e o pc que executa o controlador devem estar conectados à mesma rede (ou seja, a rede do modem). Agora que você sabe "como funciona", vamos ver "como é construído" …

Etapa 3: Criação de uma interface ROS-MATLAB

O ROS-MATLABInterface é uma interface útil para pesquisadores e alunos para prototipar seus algoritmos de robô no MATLAB e testá-lo em robôs compatíveis com ROS. Esta interface pode ser criada pela caixa de ferramentas do sistema robótico no matlab e podemos prototipar nosso algoritmo e testá-lo em um robô habilitado para ROS ou em simuladores de robô, como Gazebo e V-REP.

Para instalar a caixa de ferramentas do sistema de robótica em seu MATLAB, simplesmente vá para a opção Add-on na barra de ferramentas e pesquise por caixa de ferramentas robótica no explorador de add-ons. Usando a caixa de ferramentas robótica, podemos publicar ou assinar um tópico, como um nó ROS, e podemos torná-lo um mestre ROS. A interface MATLAB-ROS possui a maioria das funcionalidades ROS que você pode precisar para seus projetos.

Etapa 4: Obtendo o endereço IP

Para que o controlador funcione, é necessário que você saiba o endereço IP do seu robô / pc ROS e do pc que está executando o controlador no MATLAB.

Para obter o ip do seu pc:

No Windows:

Abra o prompt de comando e digite o comando ipconfig e anote o endereço IPv4

Para Linux:

Digite o comando ifconfig e anote o endereço inet. Agora que você tem o endereço IP, é hora de construir a GUI …

Etapa 5: Crie uma GUI para o controlador

Para criar a GUI, abra o MATLAB e digite guia na janela de comando. Isso abrirá o aplicativo guia, por meio do qual criaremos nossa GUI. Você também pode usar o designer de aplicativo no MATLAB para projetar sua GUI.

Estaremos criando 9 botões no total (como mostrado na fig.):

6 botões de pressão: Avançar, Recuar, Esquerda, Direita, Conectar ao Robô, Desconectar

3 botões editáveis: Ros pc ip, porta e nome do tópico.

Os botões editáveis são os botões que pegarão o ip do ROS pc, sua porta e o nome do tópico como entrada. O nome do tópico é o meio pelo qual o controlador MATLAB e o robô / pc ROS se comunicam. Para editar a string no botão editável, clique com o botão direito no botão >> vá para as propriedades do Inspetor >> String e edite o texto do botão.

Assim que sua GUI estiver concluída, você pode programar os botões. Aqui é onde a verdadeira diversão começa…

Etapa 6: Programação dos botões editáveis da GUI

A GUI é salva como um arquivo.fig, mas as funções de código / retorno de chamada são salvas no formato.m. O arquivo.m contém o código para todos os seus botões. Para adicionar funções de retorno de chamada aos seus botões, clique com o botão direito no botão> > Ver callbacks >> callback. Isso abrirá o arquivo.m para sua GUI onde aquele botão específico está definido.

O primeiro retorno de chamada que codificaremos é para o botão editável ROS IP. Na função edit1_Callback, escreva o seguinte código:

função edit1_Callback (hObject, eventdata, alças)

ros_master_ip global

ros_master_ip = get (hObject, 'String')

Aqui, a função é definida como edit1_Callback, que se refere ao primeiro botão editável. Quando inserimos um endereço IP da rede ROS neste botão editável, ele armazenará o endereço IP como uma string em uma variável global chamada ros_master_ip.

Então, logo abaixo de _OpeningFcn (hObject, eventdata, alças, varargin), defina o seguinte (veja a fig.):

ros_master_ip global

ros_master_port global

teleop_topic_name global

ros_master_ip = '192.168.1.102';

ros_master_port = '11311';

teleop_topic_name = '/ cmd_vel_mux / input / teleop';

Você acabou de codificar globalmente o ip do ros-pc (ros_master_ip), a porta (ros_master_port) e o nome do tópico do Teleop. O que isso significa é que, se você deixar os botões editáveis vazios, esses valores predefinidos serão usados quando você se conectar.

O próximo retorno de chamada que codificaremos é para o botão editável da porta.

Na função edit2_Callback, escreva o seguinte código:

função edit2_Callback (hObject, eventdata, alças)

ros_master_port global

ros_master_port = get (hObject, 'String')

Aqui, a função é definida como edit2_Callback, que se refere ao segundo botão editável. Quando inserimos a porta do ros pc / robot aqui a partir da rede ROS neste botão editável, ele armazenará a porta como uma string em uma variável global chamada ros_master_port.

Da mesma forma, o próximo retorno de chamada que codificaremos é para o botão editável do nome do tópico.

Na função edit3_Callback, escreva o seguinte código:

função edit3_Callback (hObject, eventdata, alças)

teleop_topic_name global

teleop_topic_name = get (hObject, 'String')

Semelhante a ros_master_port, também é armazenado como string em uma variável global.

A seguir, veremos as funções de retorno de chamada para os botões de pressão …

Etapa 7: Programação dos botões da GUI

Os botões que criamos anteriormente são os que usaremos para mover, conectar e desconectar o robô do controlador. Os retornos de chamada do botão de pressão são definidos da seguinte forma:

por exemplo. função pushbutton6_Callback (hObject, eventdata, alças)

Nota: dependendo da ordem em que você criou seus botões de pressão, eles seriam numerados de acordo. Portanto, a função pushbutton6 em meu arquivo.m pode ser para Avançar, enquanto em seu arquivo.m pode ser para Voltar, portanto, tenha isso em mente. Para saber qual é a função exata para o seu botão de pressão, simplesmente clique com o botão direito do mouse em >> Ver callbacks >> callbacks e ele abrirá a função para o seu botão, mas para este instrutível, estou assumindo que é igual ao meu.

Para o botão Conectar ao robô:

Na função pushbutton6_Callback (hObject, eventdata, handles):

função pushbutton6_Callback (hObject, eventdata, alças) ros_master_ip global

ros_master_port global

teleop_topic_name global

robô global

velmsg global

ros_master_uri = strcat ('https://', ros_master_ip, ':', ros_master_port)

setenv ('ROS_MASTER_URI', ros_master_uri)

rosinit

robot = rospublisher (teleop_topic_name, 'geometry_msgs / Twist');

velmsg = rosmessage (robô);

Este retorno de chamada definirá a variável ROS_MASTER_URI concatenando ros_master_ip e a porta. Então, o comando rosinit inicializará a conexão. Após a conexão, ele criará um editor de geometry_msgs / Twist, que será usado para enviar o comando velocity. O nome do tópico é o nome que fornecemos na caixa de edição. Assim que a conexão for bem-sucedida, poderemos operar os botões Forward, Backward, Left, Right.

Antes de adicionar callbacks aos botões push para frente e para trás, precisamos inicializar as velocidades linear e angular.

Portanto, abaixo de _OpeningFcn (hObject, eventdata, alças, varargin) defina o seguinte (ver fig):

global left_spinVelocity global right_spinVelocity

global forwardVelocity

global backwardVelocity

left_spinVelocity = 2;

right_spinVelocity = -2;

forwardVelocity = 3;

backwardVelocity = -3;

Nota: todas as velocidades estão em rad / s

Agora que as variáveis globais estão definidas, vamos programar os botões de movimento.

Para o botão de avanço:

função pushbutton4_Callback (hObject, eventdata, alças) velmsg global

robô global

teleop_topic_name global

global forwardVelocity

velmsg. Angular. Z = 0;

velmsg. Linear. X = forwardVelocity;

enviar (robô, velmsg);

latchpub = rospublisher (teleop_topic_name, 'IsLatching', true);

Da mesma forma para o botão de retrocesso:

função pushbutton5_Callback (hObject, eventdata, alças)

velmsg global

robô global

global backwardVelocity

teleop_topic_name global

velmsg. Angular. Z = 0;

velmsg. Linear. X = backwardVelocity;

enviar (robô, velmsg);

latchpub = rospublisher (teleop_topic_name, 'IsLatching', verdadeiro);

Da mesma forma para o botão esquerdo: função pushbutton3_Callback (hObject, eventdata, handles)

global velmsgglobal robot global left_spinVelocity

teleop_topic_name global

velmsg. Angular. Z = left_spinVelocity;

velmsg. Linear. X = 0;

enviar (robô, velmsg);

latchpub = rospublisher (teleop_topic_name, 'IsLatching', verdadeiro);

Da mesma forma para o botão direito:

robô velmsgglobal global

global right_spinVelocity

teleop_topic_name global

velmsg. Angular. Z = right_spinVelocity;

velmsg. Linear. X = 0;

enviar (robô, velmsg);

latchpub = rospublisher (teleop_topic_name, 'IsLatching', verdadeiro);

Uma vez que todas as funções de callback foram adicionadas e os arquivos salvos, podemos testar nosso controlador.

Etapa 8: Definir a configuração de rede em ROS PC (Linux)

Estaremos testando o controlador em um ros pc (Linux), o que exigirá a definição da configuração de rede. Se você também estiver executando o controlador em um pc linux, terá que definir a configuração de rede lá também.

Configuração de rede:

Abra sua janela de terminal e digite gedit.bashrc

Assim que o arquivo for aberto, adicione o seguinte:

#Robot Machine Configuration

exportar ROS_MASTER_URI = https:// localhost: 11311

# Endereço IP do nó mestre ROS

exportar ROS_HOSTNAME =

exportar ROS_IP =

echo "ROS_HOSTNAME:" $ ROS_HOSTNAME

echo "ROS_IP:" $ ROS_IP

echo "ROS_MASTER_URI:" $ ROS_MASTER_URI

Você deve seguir esta etapa todas as vezes devido à atribuição dinâmica de IP.

Etapa 9: execute o controlador

Vamos testar nosso controlador em um bot Turtle no Gazebo.

Para instalar o Gazebo, consulte

Para instalar o bot Turtle, consulte

Abra a pasta onde você salvou seus arquivos.fig e.m no MATLAB e pressione Executar (como mostrado na imagem). Isso abrirá o controlador no PC. Antes de pressionar conectar, certifique-se de que seu simulador de tartaruga está funcionando.

Para testar sua simulação TurtleBot:

Abra o Terminal no Ros pc e digite: $ roslaunch turtlebot_gazebo turtlebot_world.launch. Isso abrirá uma simulação do Turtlebot naquele PC. O nome do tópico do TurtleBot é / cmd_vel_mux / input / teleop, que já fornecemos no aplicativo. Digite o endereço IP do ros pc, a porta e o nome do tópico nos botões editáveis e pressione o botão Conectar ao Robô. Seu robô tartaruga deve começar a se mover quando você pressiona Avançar, Voltar, etc.

Para visualizar as velocidades linear e angular:

Abra um novo terminal e digite o comando: $ rostopic echo / cmd_vel_mux / input / teleop

E aí está, seu próprio ROS Robotic Controller baseado em Matlab. Se você gostou do meu instrutível, dê um voto no Concurso de Autoria pela Primeira Vez e compartilhe com o máximo de pessoas possível. Obrigada.