ROS controllers config

O ficheiro de configuração dos ros controllers  controllers.yaml pode ser expresso de forma plana, como no exemplo 1a ou de forma hierarquica como no exemplo 2a.

Uma das consequencias da diferente forma de exprimir  os elementos participantes no controlo é que no ficheiro launch estes tem de ser referidos tendo em conta a forma como foram expressos no respectivo ficheiro controllers.yaml.

Exemplo 1a: controllers.yaml

robotname:
    # Publish all joint states 
    joints_update:
      type: joint_state_controller/JointStateController
      publish_rate: 50
    # Position Controllers
    joint_1:
      type: position_controllers/JointPositionController
      joint: joint_1
      pid: {p: 1.0, i: 1.0, d: 0.0}
    joint_2:
      type: position_controllers/JointPositionController
      joint: joint_2
      pid: {p: 1.0, i: 1.0, d: 0.0}
    # Effort Controllers
    joint_3:
      type: effort_controllers/JointEffortController
      joint: joint_3

Exemplo 1b: controllers.launch

<rosparam file="$(find robotnamepkg)/config/controllers.yaml" command="load"/>

<node name="controller_spawner" pkg="controller_manager" type="spawner" respawn="false" output="screen"
      args="
          /robotname/joints_update
          /robotname/joint_1
          /robotname/joint_2
          /robotname/joint_3
      "/>

Exemplo 2a: controllers.yaml

robotname:
  controller:
    # Publish all joint states 
    state:
      type: joint_state_controller/JointStateController
      publish_rate: 50
    # Position Controllers
    position:
      joint_1:
        type: position_controllers/JointPositionController
        joint: joint_1
        pid: {p: 10.0, i: 0.0, d: 1.0}
      joint_2:
        type: position_controllers/JointPositionController
        joint: joint_2
        pid: {p: 10.0, i: 0.0, d: 1.0}
    # Effort Controllers
    effort:
      joint_3:
        type: effort_controllers/JointEffortController
        joint: joint_3

Exemplo 2b: controllers.launch

<rosparam file="$(find robotnamepkg)/config/controllers.yaml" command="load"/>

<node name="controller_spawner" pkg="controller_manager" type="spawner" respawn="false" output="screen"
      args="
          /robotname/controller/state
          /robotname/controller/position/joint_1
          /robotname/controller/position/joint_2
          /robotname/controller/effort/joint_3
      "/>

 

 

 

Cinemática dos braços róboticos eezyBotArm

A cadeia cinemática dos braços robóticos eezyBotArm, adoptada dos robots manipuladores industriais ABB-IRB460, é baseada em três actuadores, uma base rotativa e duas hastes em T. Uma das quais controlada directamente e outra de forma indirecta. A este sistema principal de duas hastes, está associado um outro sistema de hastes (no modelo 3D mais abaixo estão a roxo) cujo propósito é garantir a horizontalidade da aplicação da garra.

Todos os robots que seguem este modelo tem uma cadeia cinemática semelhante e todas as descrições, fórmulas,  e cálculos aqui apresentados, que foram efectuados com base no eezyBotArm MK2, com uma escala de 7 para 1 face ao ABB-IRB460, aplicam-se a outros braços robóticos, como o eezyBotArm MK1 e o eezyBotArm MK3, com as devidas adequações nos parâmetros usados.

Acção dos actuadores nos braços robóticos eezyBotArm

Um actuador colocado na base e que roda o suporte das hastes segundo o eixo do z (vertical com o plano) e controla o posicionamento da garra no eixo do y, conforme video abaixo.

Um actuador que está acoplado ao braço principal, a azul no video, cujo eixo de rotação se encontra na sua extremidade inferior e controla o posicionamento da garra no eixo do x dentro de uma trajectória inscrita na circunferência do seu raio, conforme video abaixo.

Um ultimo actuador está acoplado indirectamente, por meio de duas hastes intermédias,  à extremidade traseira do braço horizontal, a vermelho no video, que roda sobre o eixo na extremidade superior do braço principal e controla o posicionamento da garra no eixo do z dentro de uma trajectória inscrita na circunferência do seu raio, conforme video abaixo.

Esta haste horizontal é actuada por intermédio de duas outras hastes, a verde na imagem abaixo, que conduzem o movimento do servo.

Quando o actuador na haste A, roda para baixo (no caso de um servo quando o ângulo se move para zero), conjunto das hastes verdes desce, puxando para baixo a parte de traz da haste horizontal (ponto t), que devido ao seu eixo de rotação (ponto c), faz subir a sua parte da frente (ponto h).

Os movimentos da haste principal, a azul, em torno do ponto A e da haste horizontal, a amarelo, em torno do ponto c definem a posição do ponto h face aos eixos x e z, ou seja a distancia da projecção de de h para A, e a altura do ponto h.

A amplitude dos movimentos deste tipo de robots está condicionado pela amplitude de rotação dos motores, das engrenagens que eventualmente estejam envolvidas e das colisões que se possam verificar.

No caso do braço robóticos eezyBotArm MK2, os limites são impostos pelos:

  • Servos de 180º de amplitude de rotação;
  • Carretos envolvidos na rotação sobre o eixo z, um principal (movido pelo servo 0) com 25 dentes e o segundo com 50 dentes, o que faz com que o movimento de rotação sobre esse eixo tenha apenas 90º de amplitude;
  • Colisões entre a haste horizontal (servo 2) e a haste principal (servo 1) que implica que os servos que as movimentam têm respectivamente os seguintes limites: 60º entre os 45º e os 105º (servo 2), e 90º entre os 55º e os 145º (servo 1).

Cálculo da cinemática inversa no eezyBotArm

A cinemática inversa refere-se ao cálculo dos ângulos adequados aos diversos eixos accionados por actuadores de modo a que o ponto de acção do braço (end effector)  se posicione num ponto especifico do espaço.

Dado um determinado ponto a (ver figura mais abaixo) com as coordenadas x, y e z relativamente à origem que para facilitar consideramos estar no centro de rotação do robot a uma altura L (no eixo dos z), o calculo da cinemática inversa envolve a conversão das coordenadas cartesianas, desse ponto, em coordenadas cilíndricas e a partir delas extrair o ângulo desejado para cada um dos três actuadores.

https://pt.wikipedia.org/wiki/Coordenadas_cil%C3%ADndricas

Os cálculos são efectuados nas seguintes fases.

Primeira fase. Conversão das coordenadas cartesianas em coordenadas cilíndricas.

Nestas coordenadas, o ângulo theta é expresso em radiano e o z mantém-se cartesiano. Por isso temos:

  • theta = atan(y/x)
  • raio = srt(x*x + y*y)
  • z = z

O theta é o ângulo que se relacionada com o motor 0,  e define a rotação em torno do eixo dos z, que antes de ser transformado em graus para ser aplicado ao motor sofre a seguinte alteração:

Ângulo do motor 0 = 2 * theta + pi / 2

Numa segunda e terceira fases, efectuam-se os cálculos dos outros dois motores, que me conjunto são responsáveis pelo posicionamento nos eixos do x e do y.

Para calcular os ângulos teremos que considerar a aplicação da lei dos cossenos.

https://pt.wikipedia.org/wiki/Lei_dos_cossenos

Consideremos o terceiro caso:

c*c = a*a + b*b – 2 * a * b * cos C

Resolvemos em ordem a cos C

c*c = a*a + b*b – 2 * a * b * cos C  é equivalente a

0 = a*a + b*b – c*c – 2 * a * b * cos C é equivalente a

2 * a * b * cos C = a*a + b*b – c*c é equivalente a

cos C = (a*a + b*b – c*c) / (2 * a * b) é equivalente a

ângulo C = acos((a*a + b*b – c*c) / (2 * a * b)) a

Com base na definição de pontos expressa na imagem anterior, consideremos na aplicação da formula acima e na seguinte que:

a = L2 = distancia entre os pontos be, b = sqrt(), e c = L3 = distancia entre os pontos ef

Ângulo do motor M1 = atan(z / raio) + leicossenos(L2, sqrt(raio*raio + z*z), L3)

Pela aplicação

Ângulo do motor M2 = pi – (M1 + leicossenos(L2, L3, sqrt(raio*raio + z*z)) – pi/2)

Os ângulos calculados acima estão expresso em radiano. Antes de serem aplicados aos motores tem de ser convertidos em graus.

Abaixo segue o bloco de código em python que calcula a cinemática inversa nos braços eezyBotArm

L1 = 94
L2 = 150 
L3 = 150 
#Hipotenusa:
def hipo(x,y):
    return math.sqrt(x*x + y*y)
#Cosines law:
def lawOfCosines(a,b,c):
    rate = (a*a + b*b - c*c) / (2 * a * b)
    if abs(rate) > 1:
        if max(rate,0) == 0:
            rate = -1
        if max(rate,0) == rate:
            rate = 1
    return math.acos(rate)

def deg(rad):
    return rad * 180 / math.pi

# Posição em coordenadas cartesianas
cartP = {'xEE': x, 'yEE': y, 'zEE': z}
# Posição em coordenadas cilindricas
cylP = {'theta': math.atan(cartP['yEE']/cartP['xEE']), 'r':hipo(cartP['xEE'], cartP['yEE']), 'zhat':cartP['zEE']-L1}
zhat = cylP['zhat']
rho = hipo(cylP['r'], zhat)
# Ângulos calculados em radiano
M1 = 2*cylP['theta'] + math.pi/2
M2 = math.atan(zhat/cylP['r']) + lawOfCosines(L2,rho,L3)
M3 = M2 + lawOfCosines(L2,L3,rho) - math.pi/2
# Ajustes
angles = [M1,math.pi - M2,M3]
# Conversão dos angulos para graus
angles = [deg(angle) for angle in angles]

 

Cálculo da cinemática directa no eezyBotArm

A cinemática directa refere-se ao do ponto especifico no espaço onde se posiciona elemento de acção do braço (end effector), dados os ângulos adequados aos diversos eixos accionados por actuadores.

Neste caso, os cálculos não o inverso do aplicado acima, e passam por determinar as coordenadas cartesianas em função do calculo da coordenada cilíndrica tendo em conta os angulos dos actuadores e os parâmetros físicos do braço.

Abaixo segue o bloco de código em python que calcula a cinemática directa nos braços eezyBotArm

L1 = distancia entre o ponto b e a superfície onde assenta o braço, L2 = distancia entre os pontos be,  L3 = distancia entre os pontos ef.

# conversão dos angulos para radianos:
angles = [joint*math.pi/180 for joint in joints.data]
# cálculo intermédio para a conversão para as coordenadas cartesianas
r = L2*math.cos(math.pi - angles[1]) + L3*math.cos(angles[2]-math.pi/2) 
# Posição do ponto expresso em coordenadas cartesianas:
x = r*math.cos((angles[0]-math.pi/2)/2)
y = r*math.sin((angles[0]-math.pi/2)/2)
z = L2*math.sin(math.pi - angles[1]) + L3*math.sin(angles[2]-math.pi/2) + L

 

Folha de cálculo para a cinemática directa:

https://docs.google.com/spreadsheets/d/1DB-M-31lVDcXrwiRjAp6iKgvtpz-O-wC2fAOD7AwXrc/edit?usp=sharing

 

Fontes

https://github.com/HotBlackRobotics/ntbd

https://hackaday.io/project/157951

https://github.com/IdreesInc/EEZYbotARM-MK2-Cartesian-Coordinates

 

 

Hardware para controlo dos braços róboticos eezyBotArm

Os braços robóticos eezyBotArm baseados em servo motores, como o eezyBotArm MK1 e o eezyBotArm MK2 podem ser controlados com uma das soluções abaixo indicadas.

  • Um micro-controlador com uma biblioteca para controlo de servos, normalmente um atmega328p ou atmega2560
  • Um modulo Mini Maestro da Pololu para 12 servos, com um PC
  • Um modulo PCA9865 para 16 servos, com um micro-controlador ou um PC

Para além da opção dos movimentos estarem simplesmente programados, também poderemos considerar como inputs para definir os movimentos do braço o seguinte hardware:

  • Um conjunto de potenciómetros
  • Um joystick
  • Um IMU
  • Um Leap motion

 

EezyBotArm MK3

O braço robótico EezyBotArm MK3, faz parte da família de manipuladores robóticos eezyBotArm, e distingue-se dos anteriores membros da família por usar motores de passo (steppers) como actuadores para as hastes principais.

Os ficheiros STL para efectuar a impressão 3D, a lista de componentes a adquirir e as instruções de montagem foram partilhadas pelo autor no seguinte endereço:

https://www.thingiverse.com/thing:2838859

O braço EezyBotArm MK3 é do tamanho do MK1 e os motores de passo usados, os 28BYJ-48, tem de ser alterados para funcionarem como bipolares de modo a aumentar o seu torque.

Veja o seguinte artigo para saber mais sobre a: Cinemática do braço robot eezyBotArm MK3.

 

Problemas no Robot Arm MK2 Plus

Após a montagem e os primeiros testes conclui que o design do braço robótico Robot Arm MK2 Plus tem alguns problemas.

Este artigo é um relatório dos problemas que encontrei e deste modo lança alguns contributos para a melhoria  deste modelo de braço manipulador robótico.

O diâmetro do orifício central da base inferior é insuficiente para permitir a passagem do parafuso M6 que é usado para fixar  conjunto.

A garra tem um problema no design que impede que os dedos se toquem. O problema deve-se aos dedos baterem na engrenagem do eixo do servo (gear_drive) e desse modo impossibilita uma maior aproximação dos dedos.

Os orifícios do dedo da garra que servem como encaixe para a engrenagem secundária da garra são demasiado pequenos e dificultam o encaixe entre as duas peças. Também achei que os dedos são demasiado curtos. Desenhei uns dedos mais longos e com uns orifícios que facilitam o encaixe.

O suporte dos motores de passo (steppers) laterais não deviam fazer parte da braço (base_arm). A sua impressão como peças independentes, fixadas a base com 4 parafusos cada, facilitariam bastante a montagem dos motores e a obtenção de parafusos adequados.

As engrenagens aplicadas nos eixos dos steppers necessitam de uns parafusos e porcas difíceis de encontrar e como ficam distantes da parte plana do eixo a sua eficácia depende do aperto efectuado. Desenhei umas novas engrenagens que se baseiam no tratamento por um parafuso encostado à parte plana do eixo.

A base do braço robótico que assenta na superfície de aplicação, seja ela o chão ou o tampo de uma mesa, é a engrenagem inferior, sobre a qual vai rodando a engrenagem do motor de passo traseiro. Se a engrenagem inferior não estiver fixa a uma superfície que impeça que ela deslize quando o eixo do motor roda, ela deslizará pondo em causa o posicionamento adequado do braço.

A inexistência de mecanismos limitadores de curso do movimento não permite o posicionamento automático no início da utilização.

Outro problema, que se adensa quando se coloca os limitadores de curso de movimento, é o número de fios eléctricos (com um tamanho considerável) que ficam  enrolados ao redor do braço robótico. Ver o artigo Limitadores de Curso para o Robot Arm MK2 Plus.

Joystick no ROS

http://wiki.ros.org/joy/Tutorials/ConfiguringALinuxJoystick

# instalar software
sudo apt-get install ros-melodic-joy

# ligar o joystick e verificar se aparece o jsX ex. js0 ou js1
ls /dev/input/

# testar o joystick
sudo jstest /dev/input/js0

# verificar as permissões
ls -l /dev/input/js0

# dar permissões
sudo chmod a+rw /dev/input/js0

# rosmaster
roscore &

# configurar o joystick no parameter server do ROS
rosparam set joy_node/dev “/dev/input/js0”

# Correr o node
rosrun joy joy_node

# Verificar o ROS topic
rostopic echo joy

 

Instalar nodes de teleop (twist msg)

sudo apt install ros-noetic-teleop-tools

  • key_teleop
  • joy_teleop
  • mouse_teleop

Instalar um node de joystick teleop (twist msg)

sudo apt install ros-noetic-teleop-twist-joy

Mais informação em:

http://wiki.ros.org/teleop_twist_joy

Programar um node de joystick teleop (twist msg)

http://wiki.ros.org/joy/Tutorials/WritingTeleopNode

end

ROS moveit tutorial

Existem tutoriais diferentes conforme a versão do ROS que temos instalado, Kinetic ou Melodic, e que  se encontram disponiveis nos seguintes endereços (respectivamente):

  • http://docs.ros.org/kinetic/api/moveit_tutorials/html/index.html
  • http://docs.ros.org/melodic/api/moveit_tutorials/html/index.html

No meu caso vou seguir os tutoriais para o ROS Melodic.

O primeiro tutorial é Getting Started disponivel no seguinte endereço:

http://docs.ros.org/melodic/api/moveit_tutorials/html/doc/getting_started/getting_started.html

Este tutorial tem informações em como actualizar o ROS e instalar o moveit.

Primeiro, actualizar o sistema e instalar software

# actualizar o sistema
rosdep update
sudo apt-get update
sudo apt-get upgrade

# instalar moveit e requisitos básicos
sudo apt-get install ros-melodic-catkin python-catkin-tools
sudo apt install ros-melodic-moveit

Segundo, criar um Catkin Workspace e preparar o software de exemplo

mkdir -p ~/ws_moveit/src
cd ~/ws_moveit/src
git clone https://github.com/ros-planning/moveit_tutorials.git -b melodic-devel
git clone https://github.com/ros-planning/panda_moveit_config.git -b melodic-devel

Terceiro, obter as dependências para os pacotes instalados

cd ~/ws_moveit/src
rosdep install -y --from-paths . --ignore-src --rosdistro melodic

Quarto, configurar o catkin workspace:

cd ~/ws_moveit
catkin config --extend /opt/ros/${ROS_DISTRO} --cmake-args -DCMAKE_BUILD_TYPE=Release
catkin build

Quinto, declarar o Source do catkin workspace:

source ~/ws_moveit/devel/setup.bash

Opcionalmente pode ser efectuado a execução automática ao adicionar a linha acima ao .bashrc, executando o seguinte comando:

echo 'source ~/ws_moveit/devel/setup.bash' >> ~/.bashrc

 


 

Depois de instalado o ROS moveit e o software de exemplo, está na hora de abordar o plugin de planeamento do movimento para o RViz.

As informações detalhadas em como proceder estão disponiveis no seguinte endereço:

http://docs.ros.org/melodic/api/moveit_tutorials/html/doc/quickstart_in_rviz/quickstart_in_rviz_tutorial.html

roslaunch panda_moveit_config demo.launch rviz_tutorial:=true

Nos displays adicionar os seguintes plugins:

  • MotionPlanning
  • PlanningScene
  • Trajectory

O display principal para explorarmos um braço robótico no moveit e rviz é o MotionPlanning

Nota sobre a compilação e o efeito no path quando usamos o workspace ws_moveit. Após a compilação ser exectuada deveremos fazer a source do setup.bash outra vez. Caso contrario o ROS não encontra os pacotes compilados neste workspace. Exemplo completo nos seguintes comandos:

cd ~/ws_moveit
catkin build
source devel/setup.bash

Nota sobre o uso do joint_state_publisher_gui no rviz. Quando se usa o moveit, o interface deixa de aparecer no rviz, mesmo quando já se deixou de usar o moveit. Por outro lado, o launch file deve ser actualizado de modo a lançar directametent o joint_state_publisher_gui, caso contrario recebemos o seguitne aviso:

The ‘use_gui’ parameter was specified, which is deprecated. We’ll attempt to find and run the GUI, but if this fails you should install the ‘joint_state_publisher_gui’ package instead and run that. This backwards compatibility option will be removed in Noetic.

 

URDF

A expressão URDF  é um acrónimo de Unified Robot Description Format, ou seja, em português um Formato Unificado para Descrição de Robot.

Os ficheiros URDF são expressos em formato XLM, e são compostos fundamentalmente por etiquetas Link, que descrevem os seus componentes  mecanicos e etiquetas Joint, que descrevem como os diversos Links se relacionam.

Informações básicas sobre o URDF no wiki do ROS

  • http://wiki.ros.org/urdf
  • http://wiki.ros.org/urdf/XML
  • http://wiki.ros.org/urdf/Tutorials

Preparar pacote do ROS

Antes de avançar na exposição da estrutura e formato dos ficheiros URDF devemos preparar uma pacote do ROS para conter os ficheiros que vamos usar.

cd ~/catkin_ws/src
catkin_create_pkg description_tutorial std_msgs rospy roscpp rviz controller_manager gazebo_ros joint_state_publisher robot_state_publisher 
rosdep install -y --from-paths . --ignore-src --rosdistro kinetic
cd description_tutorial/
mkdir launch
mkdir urdf
cd ~/catkin_ws/
catkin_make

nano launch/display1.launch

<launch>
<arg name="model" default="robot1.urdf" />
<arg name="gui" default="True" />

<param name="robot_description" textfile="$(find description_tutorial)/urdf/$(arg model)" />
<param name="use_gui" value="$(arg gui)"/>

<node name="joint_state_publisher" pkg="joint_state_publisher" type="joint_state_publisher" />
<node name="robot_state_publisher" pkg="robot_state_publisher" type="robot_state_publisher" />
<node name="rviz" pkg="rviz" type="rviz" args="-d $(find description_tutorial)/robot1.rviz" required="true" />
</launch>

Para executar a visualização de um robot descrito num ficheiro urdf, usar o seguinte comando:

roslaunch description_tutorial display1.launch model:=urdf/robot1.urdf

Anatomia de um ficheiro URDF

Um ficheiro URFD é composto por etiquetas no formato tipico do XML, seguindo uma hierarquia especifica.

  • robot
    • link name=”link_1″
      • inertial
        • origin xyz=”0 0 0″ rpy=”0 0 0″
        • mass value=”1″
        • inertia ixx=”100″ ixy=”0″ ixz=”0″ iyy=”100″ iyz=”0″ izz=”100″
      • visual
        • origin xyz=”0 0 0″ rpy=”0 0 0″
        • geometry
          • [box, cylinder, sphere, mesh]
        • material
          • color rgba=”1 0 0 1.0″
          • texture
      • collision
        • origin xyz=”0 0 0″ rpy=”0 0 0″
        • geometry
          • [box, cylinder, sphere]
    • joint name=”joint_1″ type=”floating”
      • parent link=”link_1″
      • child link=”link_2″
      • origin xyz=”0 0 0″ rpy=”0 0 0″
      • axis xyz=”0 0 1″
      • calibration rising =”0.0″ falling=”0.0″
      • dynamics damping=”0.0″ friction=”0.0″
      • limit effort=”30″ velocity=”1.0″ lower=”-2.2″ upper=”0.7″
      • safety_controller k_velocity=”10″ k_position=”15″ soft_lower_limit=”-2.0″ soft_upper_limit=”0.5″

Passemos a exemplos de ficheiros URDF onde se faz uso das etiquetas indicadas acima.

Tomemos como objecto de exemplo o braço róbotico eezyBotArm MK1, que por ter uma cadeia cinamática em malha fechada, iremos usar a cadeia cinemática equivalente em malha aberta.

Esquema de um braço robótico eezBotArm Mk1

Tamanhos em milimeteros

AC = 32
AB = 70
CQ = 35
DE = 34
DF = 34
FG = 17
GH = 80
IJ = 1
JK = 95
NO = 1
OP = 127
LH = 79
HM = 35

Comecemos pela base, que será representada por um cilindro que na figura acima está definido pelos A, B, C e está fixo ao mundo de forma imutavel.

nano ~/catkin_ws/src/description_tutorial/urdf/robot1.urdf

<?xml version="1.0"?>
<robot name="robot1">
<link name="base_link">
<visual>
<origin xyz="0 0 0" rpy="0 0 0" />
<geometry>
<cylinder length="0.032" radius="0.035"/>
</geometry>
<material name="blue"/>
</visual>
</link>
<material name="blue">
<color rgba="0 0 1 1"/>
</material>
</robot>

 

Como se pode ver na imagem o cilindro é representado afundado até meia altura no plano de representação. Isto acontece porque nos objectos do tipo: box, cylinder, e sphere, a origem é no centro do objecto.

Para dispormos adequadamente o objecto teremos de indicar o deslocamento da origem. Para o efeito colocamos o valor z da origem do visual do link em 0.016.

nano ~/catkin_ws/src/description_tutorial/urdf/robot1.urdf

<?xml version="1.0"?>
<robot name="robot1">
<link name="base_link">
<visual>
<origin xyz="0 0 0.016" rpy="0 0 0" />
<geometry>
<cylinder length="0.032" radius="0.035"/>
</geometry>
<material name="blue"/>
</visual>
</link>
<material name="blue">
<color rgba="0 0 1 1"/>
</material>
</robot>

 

A seguir passemos ao segundo objecto, definido pelos pontos D, E e F, é do tipo box e roda sobre o eixo z no ponto Q.

Para definirmos outro objecto (link) temos também de definir a ligação entre eles (joint).

nano ~/catkin_ws/src/description_tutorial/urdf/robot1.urdf

 

<?xml version="1.0"?>
<robot name="robot1">
<link name="base_link">
<visual>
<origin xyz="0 0 0.016" rpy="0 0 0" />
<geometry>
<cylinder length="0.032" radius="0.035"/>
</geometry>
<material name="blue"/>
</visual>
</link>

<joint
name="joint_1"
type="revolute">
<origin xyz="0 0 0" rpy="0 0 0" />
<parent link="base_link" />
<child link="link_1" />
<axis xyz="0 0 1" />
<limit
effort="0"
velocity="0"
lower="-0.7854" upper="0.7854"/>
<!-- [-45,45]-->
</joint>

<link name="link_1">
<visual>
<origin xyz="0 0 0" rpy="0 0 0" />
<geometry>
<box size="0.01 0.034 0.034" />
</geometry>
<material name="blue" />
</visual>
</link>

<material name="blue">
<color rgba="0 0 1 1"/>
</material>
</robot>

Pelas imagens podemos verificar que a posicão do objecto não é adequada. O seu centro fica sobre a origem do link anterior. Para resolver a situação deslocamos a origem do joint para a soma da altura da base, mas metade da altura do novo objecto.

 <joint
name="joint_1"
type="revolute">
<origin xyz="0 0 0.049" rpy="0 0 0" />
<parent link="base_link" />
<child link="link_1" />
<axis xyz="0 0 1" />
<limit
effort="0"
velocity="0"
lower="-0.7854" upper="0.7854"/>
<!-- [-45,45]-->
</joint>

Após esta correção a apresentação fica conforme desejado.

A seguir passemos ao terceiro objecto, a haste vertical definida pelos pontos I, J e K, do tipo box e roda sobre o eixo x no ponto G.

Mais uma vez, para definirmos outro objecto (link) temos também de definir a ligação entre eles (joint).  Aproveitamos também para redefinir a cor da box do link_1, para vermelho.

nano ~/catkin_ws/src/description_tutorial/urdf/robot1.urdf

<?xml version="1.0"?>
<robot name="robot1">
<link name="base_link">
<visual>
<origin xyz="0 0 0.016" rpy="0 0 0" />
<geometry>
<cylinder length="0.032" radius="0.035"/>
</geometry>
<material name="blue"/>
</visual>
</link>

<joint
name="joint_1"
type="revolute">
<origin xyz="0 0 0.049" rpy="0 0 0" />
<parent link="base_link" />
<child link="link_1" />
<axis xyz="0 0 1" />
<limit
effort="0"
velocity="0"
lower="-0.7854" upper="0.7854"/>
<!-- [-45,45]-->
</joint>

<link name="link_1">
<visual>
<origin xyz="0 0 0" rpy="0 0 0" />
<geometry>
<box size="0.01 0.034 0.034" />
</geometry>
<material name="red" />
</visual>
</link>

<joint name="joint_2" type="revolute">
<origin xyz="0 0 0" rpy="0 0 0" />
<parent link="link_1" />
<child link="link_2" />
<axis xyz="1 0 0" />
<limit
effort="0"
velocity="0"
lower="-0.6109" upper="0.9599"/>
<!-- [-35,55]-->
</joint>

<link name="link_2">
<visual>
<origin xyz="0 0 0" rpy="0 0 0" />
<geometry>
<box size="0.01 0.01 0.08" />
</geometry>
<material name="blue" />
</visual>
</link>

<material name="red">
<color rgba="1 0 1 1"/>
</material>

<material name="blue">
<color rgba="0 0 1 1"/>
</material>

</robot>

Mais uma vez verificamos que  a posição do objecto não é adequada.

As duas razões são, a posição do joint G no link_1 e no link_1 estão no centro dos respectivos objctos, e portanto teremos que redefinir, a origem do joint pelo deslocamento na vertical de metade da altura (0.017) do suporte (link_1), e a origem do visual pelo deslocamento na vertical de metade da altura (0.04) da haste (link_2).

<joint name="joint_2" type="revolute">
<origin xyz="0 0 0.017" rpy="0 0 0" />
<parent link="link_1" />
<child link="link_2" />
<axis xyz="1 0 0" />
<limit
effort="0"
velocity="0"
lower="-0.6109" upper="0.9599"/>
<!-- [-35,55]-->
</joint>

<link name="link_2">
<visual>
<origin xyz="0 0 0.04" rpy="0 0 0" />
<geometry>
<box size="0.01 0.01 0.08" />
</geometry>
<material name="blue" />
</visual>
</link>

 

Por último passemos ao quarto objecto, a haste horizontal definida pelos pontos P, O e N, do tipo box e roda sobre o eixo x no ponto H.

Mais uma vez, para definirmos outro objecto (link) temos também de definir a ligação entre eles (joint).

Chamo a atenção que desta vez foram efectuados acertos logo de inicio. No joint_3 a origem z foi deslocada 0.08 unidades, e a origem  ydo visual do link_3 foi deslocada 0.0225 unidades.

nano ~/catkin_ws/src/description_tutorial/urdf/robot1.urdf

<?xml version=”1.0″?>
<robot name=”robot1″>
<link name=”base_link”>
<visual>
<origin xyz=”0 0 0.016″ rpy=”0 0 0″ />
<geometry>
<cylinder length=”0.032″ radius=”0.035″/>
</geometry>
<material name=”blue”/>
</visual>
</link>

<joint name=”joint_1″ type=”revolute”>
<origin xyz=”0 0 0.049″ rpy=”0 0 0″ />
<parent link=”base_link” />
<child link=”link_1″ />
<axis xyz=”0 0 1″ />
<limit
effort=”0″
velocity=”0″
lower=”-0.7854″ upper=”0.7854″/>
<!– [-45,45]–>
</joint>

<link name=”link_1″>
<visual>
<origin xyz=”0 0 0″ rpy=”0 0 0″ />
<geometry>
<box size=”0.01 0.034 0.034″ />
</geometry>
<material name=”red” />
</visual>
</link>

<joint name=”joint_2″ type=”revolute”>
<origin xyz=”0 0 0.017″ rpy=”0 0 0″ />
<parent link=”link_1″ />
<child link=”link_2″ />
<axis xyz=”1 0 0″ />
<limit
effort=”0″
velocity=”0″
lower=”-0.6109″ upper=”0.9599″/>
<!– [-35,55]–>
</joint>

<link name=”link_2″>
<visual>
<origin xyz=”0 0 0.04″ rpy=”0 0 0″ />
<geometry>
<box size=”0.01 0.01 0.08″ />
</geometry>
<material name=”blue” />
</visual>
</link>

<joint name=”joint_3″ type=”revolute”>
<origin xyz=”0 0 0.08″ rpy=”0 0 0″ />
<parent link=”link_2″ />
<child link=”link_3″ />
<axis xyz=”1 0 0″ />
<limit
effort=”0″
velocity=”0″
lower=”-1.2217″ upper=”0.3491″/>
<!– [-70,20]–>
</joint>

<link name=”link_3″>
<visual>
<origin
xyz=”0 0.0225 0″
rpy=”0 0 0″ />
<geometry>
<box size=”0.0075 0.127 0.01″ />
</geometry>
<material name=”red” />
</visual>
</link>

<material name=”red”>
<color rgba=”1 0 1 1″/>
</material>

<material name=”blue”>
<color rgba=”0 0 1 1″/>
</material>

</robot>

No final, conforme video abaixo, podemos manipular a posição dos 3 joints com o joint_state_publisher_gui.

 

 

Controlo de PWM com PCA9685 e Pontenciometros variaveis

Este artigo foi efectuado para documentar os testes que efectuei com os seguintes braços róboticos educativos cujas algumas das peças mecanicas se podem fazer com uma impressora 3D.

Para efectuar o controlo do braço recorri ao hardware e software descrito mais abaixo.

sdr

O controlo dos 4 servos do braço é efectuado por um conjunto de 4 potenciómetros cuja posição é lida pelo recurso á leitura de 4 dos pinos analógicos de um Arduino Uno, que é convertido num comprimento de pulso mapeado entre o valor minimo e máximo de comprimento de pulso ,  enviado por I2C para o módulo PCA9685, que gera o PWM para a respectiva posição para cada um dos servos.

Hardware

A parte electrónica é composta por:

  • um microcontrolador ATMEGA 328P (Arduino Uno)
  • um modulo PCA9685
  • quatro potenciómetros
  • uma resistencia
Ligações entre os potenciometros, mcu, PCA9685 e servos MG996

Software

Para implementar o procedimento descrito existe um pequeno programa disponivel mais abaixo e que necessita da biblioteca Adafruit PWM Servo Driver para o Arduino que se pode instalar no arduino ide.

A biblioteca pode ser instalada recorrendo ao gestor de bibliotecas, pesquisar por: “adafruit pwm” e instalar. Mas também está disponivel no seguinte endereço

https://github.com/adafruit/Adafruit-PWM-Servo-Driver-Library

Programa para o Arduino Uno

servo_pca9685 _potenciometer_v2

#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>

Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();

#define SERVOCOUNT 4

#define SERVOMIN 150 // this is the 'minimum' pulse length count (out of 4096)
#define SERVOMAX 600 // this is the 'maximum' pulse length count (out of 4096)

int potpin[SERVOCOUNT] = {0};
int potval[SERVOCOUNT] = {0};
int srvang[SERVOCOUNT] = {0}; 
int srvpls[SERVOCOUNT] = {SERVOMIN};

void setup() {
Serial.begin(115200);
potpin[0]=0;
potpin[1]=1;
potpin[2]=2;
potpin[3]=3;
pwm.begin();
pwm.setPWMFreq(60);
delay(10);
}

void loop() {
int i;

for(i = 0; i < SERVOCOUNT; i++) {
// read potentiometer
potval[i] = analogRead(potpin[i]);
// map potentiometer value to degrees
srvang[i] = map(potval[i], 0, 1023, 0, 180);
// map degrees to pulse length
srvpls[i] = map(srvang[i], 0, 180, SERVOMIN, SERVOMAX);
// print to give feedback 
Serial.print(potval[i]); Serial.print("\t"); Serial.print(srvang[i]); Serial.print("\t");
// send pwm to servo
pwm.setPWM(potpin[i], 0, srvpls[i]); 
}

Serial.println("\n");
}

 

Referências:

https://learn.adafruit.com/16-channel-pwm-servo-driver/using-the-adafruit-library

Arduino PCA9685 example

 

Making of EEZYbotARM MK2

Após ter feito um braço robótico EEZYbotARM (MK1), em que não cumpri exactamente as instruções pois não encontrei o tubo, e de ter tentado sem sucesso criar uma descrição do braço num ficheiro URDF, iniciei a construção do EEZYbotARM MK2.

O braço EEZYbotARM MK2, tal como o MK1 tem os ficheiros STL disponiveis para podermos imprimir parte das suas peças mecânicas numa impressora 3D e está descrito nos seguintes links:

  • http://www.eezyrobots.it/eba_mk2.html
  • https://www.thingiverse.com/thing:1454048
  • https://www.instructables.com/id/EEZYbotARM-Mk2-3D-Printed-Robot/

As partes mecânicas e a respectiva montagem estão bem descritas nos links acima.

A parte electrónica também tem a descrição, no artigo do instructables, de uma das soluções possíveis que é usar o controlador USB servo Mini Maestro da Pololu.  Nesta solução o software é fornecido com o controlador e instalado no PC

Outra solução possível, conforme indicado na informação disponível no thingverse, e assim como no instructables  é usar uma app para o android e um arduino. As informações sobre esta solução estão disponíveis em:

  • https://www.instructables.com/id/Android-APP-to-Control-a-3DPrinted-Robot/

A ideia de fazer este braço róbotico é também usa-lo com o ROS conforme exposto no seguinte link:

https://hotblackrobotics.github.io/en/blog/2018/01/17/ntbd-guide-part-I/

Existe também o seguinte trabalho que descreve o uso do braço robótico EEZYbotARM MK2 com o ROS:

eezyarm_APIEMS2019_paper_259

No entanto este documento não informa nem sobre o sobre qual a electrónica e software usado.

Por ultimo também será possível implementar o controlo do braço recorrendo ao ROS moveit.

Parte 1: Aquisição das peças necessárias para o braço robótico

As peças necessárias são 4 servos, esferas, um rolamento e um conjunto de diversas porcas, parafusos e anilhas.

3 x Servo Tower Pro MG955 ou MG946 ou MG996
1 x SG90 SERVO

1 x rolamento 606zz (6mm x 17mm x 6mm)

32 x esferas 6mm (diametro)

2 x parafuso M3 x 10 mm fenda
5 x parafuso M3 x 20 mm
2 x parafuso M3 x 25 mm
5 x parafuso M4 x 20 mm
1 x parafuso M4 x 35 mm ( original: 1 x parafuso M4 x 30)
1 x parafuso M4 x 50 mm ( original: 1 x parafuso M4 x 40)
1 x parafuso M6 x 25 mm

1 x varão roscado M4 x 32 mm
1 x varão roscado M4 x 60 mm

3 x porca M3
5 x porca M3 auto-bloqueante
9 x porca M4 auto-bloqueante
1 x porca M6  auto-bloqueante

2 x anilha M3
8 x anilha M4
1 x anilha M6

Esta lista de materiais pode ser ligeiramente diferente da original, por exemplo uso mais esferas, e em alguns pormenores, como por exemplo os parafusos, não tem de ser exactamente igual.

Parte 2: Impressão dos componentes para o braço robótico

Lista dos componentes impressos por ordem de impressão.

A ordem de impressão dos componentes foi escolhida de modo a ir efectuando a respectiva montagem.

Base

  • EBAmk2_001_base.STL
  • EBAmk2_010_gearservo.STL
  • EBAmk2_012_mainbase.STL
  • EBAmk2_013_lower base.STL
  • EBAmk2_011_gearmast_full.STL

Braço

  • EBAmk2_002_mainarm.STL
  • EBAmk2_003_varm.STL
  • EBAmk2_004_link135.STL
  • EBAmk2_005_link135angled.STL
  • EBAmk2_006_horarm__.STL
  • EBAmk2_007_trialink.STL
  • EBAmk2_008_link147_new.STL
  • EBAmk2_009_trialinkfront.STL

Garra

  • EBAmk2_014_claw base.STL
  • EBAmk2_015_claw finger dx.STL
  • EBAmk2_016_claw gear drive.STL
  • EBAmk2_017_claw finger sx.STL
  • EBAmk2_018_claw gear driven.STL

Cobertura da base

EBAmk2_019_drive cover.STL

Não impressos

  • EBAmk2_010_gearservo_22DENTI.STL
  • EBAmk2_011_gearmast.STL
  • EBAmk2_006_horarm_plate.STL

Parte 3: Montagem do braço róbotico

A montagem do braço robótico é efectuada em várias fases e está descrita mais abaixo. Posteriormente encontrei o seguinte video, em inglês, que explica com bastante pormenor a montagem do braço robótico.

Entre a descrição e o video creio que fica bastante claro o que é que é necessário e como se monta o braço robótico.

Montagem da base do braço robótico

A base, que é composta pelas seguintes peças:

  • Peças impressas ( 5 peças, das indicadas acima)
  • 1 x Servo MG966
  • 1 x rolamento 606 ZZ
  • 32 x esferas 6 mm
  • 2 x parafusos (1 mm x 5mm), (fixar o hub do servo à gearservo)
  • 1 x  parafuso M3 x 10 mm, (fixar o hub com engrenagem ao servo)
  • 3 x parafuso M3 x 20 mm
  • 2 x parafuso M3 x 25 mm
  • 1 x parafuso M6 x 25 mm
  • 3 x porcas M3
  • 2 x porcas M3 auto-bloqueante
  • 1 x porca M6 auto-bloqueantes
  • 1 x anilha M6
Passo 1:  montar o servo MG996R

Peças usadas:

  • 1 x 012_mainbase
  • 1 x Servo MG966
  • 4 x parafusos fornecidos com o servo

Para encaixar o servo na mainbase, retirar os 4 parafusos inferiores do servo e retirar a tampa inferior. Encaixar o servo na posição, colocar a tampa e voltar a colocar os parafusos no sitio.

A mainbase não tem os furos para fixar o servo. Fazer os furos com um arame fino e quente. De seguida Usar os 4 parafusos para fixar o servo à mainbase. 

Passo 2: Montar o suporte das esferas com o rolamento

Peças usadas

  • 1 x 013_lower base.STL
  • 3 x parafuso M3 x 20 mm
  • 3 x porcas M3
  • 1 x rolamento 606 ZZ

Primeiro encaixam-se as 3 porcas M3 nos locais apropriados. Provavelmente será necessário limar um pouco, ou aquecer as porcas, de modo a conseguir encaixar devidamente as porcas.

De seguida encaixa-se o rolamento no espaço destinado ao efeito e aplica-se os respectivos parafusos de modo a fixar a base

 

Passo 3: aplicar a engrenagem ao servo

Peças usadas

  • 1 x 010_gearservo
  • 1 x  parafuso M3 x 10 mm
  • 1 x suporte circular para o eixo do servo (fornecido com o servo)

Antes de aplicar a engrenagem verificar se está bem impressa e eventualmente retirar algum imperfeição ou algum plástico a mais que se tenha acumulado nas primeiros camadas.

Também convém determinar qual é a amplitude do servo, o seu mínimo, máximo e centro. Deixando o servo posicionado ao centro.

Aplicar o suporte circular préviamente encaixado  à engrenagem no eixo do servo (e eventualmente fixo com 2 parafusos pequenos). Fixar o conjunto com o parafuso M3.

Passo 4: aplicar as esferas e montar a base rotativa

Peças usadas

  • 1 x 001_base.STL
  • 1 x 011_gearmast_full
  • 32 x esferas 6 mm
  • 2 x parafuso M3 x 25 mm (com 2 porcas fixar a gearmaster à base)
  • 1 x parafuso M6 x 25 mm
  • 2 x porcas M3 auto-bloqueantes
  • 1 x porca autoblocante M6
  • 1 x anilha M6

Antes de aplicar a engrenagem verificar se está bem impressa e eventualmente retirar algum imperfeição ou algum plástico a mais que se tenha acumulado nas primeiros camadas.

Numa primeira fase, aplicar a porca auto-bloqueantes M6 no local apropriado na parte de baixo da base.

De seguida aplicar o gearmaster com o rebordo de acondicionamento das esferas para baixo, na parte de baixo da base, fixando-o com 2 parafusos M3 de 25 mm e 2 porcas auto-bloqueantes M3.

Depois de preparar a base com a engrenagem colocar as esferas no socalco apropriado e manter peça na vertical de modo a que as esferas se mantenham na devida posição.

De seguida encaixar a base com engrenagem na engrenagem do servo sem deixar fugir as esferas.

Fixar os dois elementos com o parafuso M6, com anilha, que enrosca na porca M6 préviamente colocada na base. Apertar quanto baste de modo a não dificultar o movimento.

Montagem do braço robótico

Após finalizar a montagem da base do braço passamos a montagem do sistema de alavancas do braço que são comandadas por dois servos.

Esta parte do braço robótico, é composto pelas seguintes peças:

  • Peças impressas ( 8 peças, das indicadas acima)
  • 1 x Varão roscado M4 com 32 mm
  • 8 x parafusos fixadores do servo

 

Passo 5: aplicar as alavancas principais do braço

Peças usadas:

  • 002_mainarm
  • 003_varm
  • 1 x varão roscado M4 com 32 mm
  • 8 x parafusos fixadores do servo

Antes de começar este passo, determinar qual é a amplitude dos servos, o seu mínimo, máximo e centro. Deixar os servos posicionados ao centro.

Também deve preparar o fixador para o eixo do servo, pois é necessário retirar uma aba ao fixador longitudinal (o que tem 2 abas)

Como os buracos onde vai passar o varão roscado estão com certeza muito apertados deve-se afinar o seu diâmetro com uma lima redonda até o varão roscado deslizar sem muito atrito nos diversos orifícios das 2 hastes impressas.

Na primeira fase deste passo, coloca-se a haste maior (002_mainarm) no local adequado (com a curvatura para o lado da pequena haste existente base), insere-se de seguida o varão roscado M4 com 32 mm.

Na segunda fase, coloca-se a haste mais pequena (003_varm) e avança-se o varão roscado até estar a face nos dois lados.

Com o eixo dos servos posicionado na posição central, aplica-se o fixador no eixo dos servos. De acordo com o seguinte procedimento:

Na haste grande, o fixador fica a apontar para cima. Na haste pequena o fixador fica a apontar para o lado da haste, que fica mais ou menos na horizontal. Para montar o fixador, deve-se usar o parafuso que vem com os servos.

Como senti dificuldades na fixação dos servos com os parafusos. Será melhor adequar melhor os orifícios na peça impressa ao diâmetro dos parafusos que se vai usar e enroscar primeiro os parafusos mesmo sem o servo para testar primeiro.

Passo 6: montar as hastes verticais traseiras

Peças usadas

  • 004_link135
  • 005_link135angled
  • 2 x parafuso M4 x 20 mm
  • 2 x porca M4 auto-bloqueante

Preparar os buracos onde vão passar os parafusos M4 com uma lima de modo a que os parafusos deslizem e rodem sem muito atrito nos diversos orifícios das hastes (link135 e  link135angled).

Na primeira fase coloca-se a haste recta com a nervura para o lado de fora, no espaço apropriado para o efeito.

Fixa-se com um parafuso M4 de 20 mm e uma porca M4 auto-bloqueante. O aperto ao parafuso deve ser dado de forma a que o movimento não sofra atrito.

Na segunda fase, coloca-se a haste curvada com a nervura para o lado de dentro, e a parte saliente da curvatura orientada para traz. Aplica-se com o parafuso M4 de 20 mm e uma porca M4 auto-bloqueante. O aperto ao parafuso deve ser dado de forma a que o movimento não sofra atrito.

Passo 7: Montar a haste horizontal e triângulo superior

Peças usadas:

  • 006_horarm__
  • 007_trialink
  • 008_link147_new
  • 1 x varão roscado M4 com 60 mm
  • 2 x parafuso M4 x 20 mm
  • 1 x parafuso M4 x 30 mm
  • 5 x porca M4 auto-bloqueante

Todos os orifícios devem ser preparados préviamente com uma lima de modo a que o varão roscado e os parafusos deslizem e rodem sem muito atrito nos diversos orifícios.

Primeiro encaixamos a haste horizontal (horarm) no local apropriado.  Seguidamente inserimos o varão roscado no orifício até ficar à face do encaixe (de forma a suster a haste).

Em segundo lugar encaixamos o triângulo (trialink) com a face plana para fora no espaço apropriado e continuamos a inserir o varão roscado (que previamente tinha ficado à face) pelo furo do triângulo. Apertar de ambos os lados com porcas M4 auto-bloqueantes.

Em terceiro lugar fixamos as duas hastes verticais na traseira da haste horizontal.

Numa primeira fase fixamos a haste com ângulos no orifício posterior na parte de dentro do triângulo com um parafuso M4 de 35 mm e uma porca M4 auto-bloqueante (este parafuso pode ser M4 25 mm).

Na fase seguinte fixamos a haste rectilínea no orifício posterior da haste horizontal, pela parte de fora, com um parafuso M4 de 20mm e uma porca M4 auto-bloqueante.

Em quarto lugar, com um parafuso M4 de 20mm e uma porca M4 auto-bloqueante, montamos a haste rectilínea maior (link147_new), por dentro no orifício do triângulo e com a nervura para fora.  

Passo 8: Montar terminação da haste horizontal

Peças usadas:

  •  009_trialinkfront
  • 1 x parafuso M4 x 35 mm
  • 1 x parafuso M4 x 50 mm
  • 2 x porca M4 auto-bloqueante

Neste passo vamos montar o suporte da garra (trialinkfront) na parte frontal da haste horizontal superior e no final da haste lateral superior.

Todos os orifícios devem ser preparados préviamente com uma lima de modo a que o varão roscado e os parafusos deslizem e rodem sem muito atrito nos diversos orifícios.

Como a garra (claw base) aplica no suporte da garra  (trialinkfront), num encaixe justo. Antes de prosseguir confirmar se as duas peças encaixam devidamente. Caso seja necessário deve desbastar a zona de encaixe no suporte da garra.

Primeiro aplica-se o suporte da garra no meio do encaixe da haste horizontal. Depois insere-se um parafuso M4 de 35mm no orifício e aperta-se uma porca M4 auto-bloqueante para o fixar.

Segundo, fixa-se a parte de cima da garra à terminação da haste lateral, com um parafuso  M4 de 50 mm no orifício e aperta-se uma porca M4 auto-bloqueante para o fixar.

Montagem da garra

Após a montagem das hastes do braço robótico a fase seguinte é montar a garra e aplicar no braço.

Passo 9: montar a garra e aplicar no suporte da garra

Peças usadas:

  • 1 x claw base
  • 1 x claw finger dx
  • 1 x claw gear drive
  • 1 x claw finger sx
  • 1 x claw gear driven
  • 1 x servo Tower Pro SG90
  • 2 x parafuso M3 com 20 mm
  • 2 x parafuso para montar servo
  • 1 x parafuso para montar suporte no eixo do servo

Todos os orifícios por onde passam os parafusos devem ser preparados préviamente com uma lima de modo a que o varão roscado e os parafusos deslizem e rodem sem muito atrito nos diversos orifícios.

A engrenagem (claw gear driven) tem duas saliências que servem como encaixe nos dois orifícios apropriados no dedo da garra (claw finger sx).

Antes de prosseguir deve certificar de que essas duas peças encaixam devidamente. Se não encaixarem deve-se desbastar os excesso nas saliências até estarem encaixarem.

O eixo do servo deve ser colocado nos zero graus. Mais tarde o fixador que é aplicado no eixo deve ficar posicionado para a frente. Deste modo quando o eixo do servo está no ângulo zero graus a garra está completamente fechada, e quando está no ângulo 180 graus  a garra está completamente aberta.

Após os procedimentos preparatórios, a primeira coisa a fazer é montar o servo no local apropriado. Para o montar devem ser usados os dois parafusos para esse efeito que vêm com o servo.

A segunda coisa a fazer é fixar a engrenagem (claw gear drive) junto com o fixador (que vem com o servo) no eixo do servo, e usar o parafuso que vem como o servo para prender o conjunto.

Em terceiro lugar, deve encaixar a engrenagem (claw gear driven) no dedo da garra (claw finger sx) e montar o conjunto alinhado com o orifício à direita na base da garra ( claw base), usando um parafuso M3 de 20 mm, uma anilha M3 e uma porca M3 auto bloqueante.

Em quarto lugar, proceder à montagem do outro dedo da garra, no orifício à esquerda na base da garra (claw base), usando um parafuso M3 de 20 mm, uma anilha M3 e uma porca M3 auto bloqueante.

Com a garra montada o ultimo passo é encaixar a garra no suporte da garra que está a haste horizontal, e fixar o conjunto com um parafuso M3 de 10 mm e uma porca M3 auto-bloqueante.

 

Finalizar a montagem da garra

Após a montagem da, base, hastes e garra do braço robótico a ultima coisa que falta da parte mecânica é a cobertura da base.

Passo 10: montar a cobertura da base

Peças usadas:

  • 019_drive cover

Para a aplicar a cobertura da base basta colocar no local e pressionar.

Com este passo, a montagem parte mecânica fica completa.

Parte 4: A electrónica de controlo do braço

Conforme indicado na introdução, o autor do braço refere as seguintes soluções:

  • controlador USB servo Mini Maestro da Pololu + sofware proprietario no pc
  • arduino uno + placa bluetooth ( HC-06) + sketch para arduino + app para android.

Para além das soluções do autor é possível ainda usar outras soluções disponíveis na internet como por exemplo:

O controlo do braço em ROS o método ntbd.

https://hotblackrobotics.github.io/en/blog/2018/01/17/ntbd-guide-part-I/

Também é possível usar outra solução testada previamente com o MK1, e que se baseia na placa PCA9685 + arduino + potenciómetros.