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

 

 

EezyBotArm MK2

O EezyBotArm MK2 é a segunda versão da família de braços robóticos educativos EezyBotArm desenhados para serem fabricados em impressoras 3D e com instruções de montagem disponíveis na Internet.

A informação original do autor está disponível nos seguintes endereços:

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

No entanto, sendo este provavelmente o mais conhecido e bem sucedido braço da família de robots EezyBotArm, existe mais informação disponível na Internet para a montagem e exploração deste braço robótico do que para qualquer um dos outros.

Para a impressão e montagem do braço recolhi e publiquei informação em português, incluindo uma lista de materiais actualizada, no artigo sobre como Fazer o braço robótico EezyBotArm MK2.

Cinemática do eezyBotArm MK2

Devido ás suas características este braço é capaz de rodar apenas 90 graus, 45 para a sua direita, e 45 para a sua esquerda, e alcançar entre 7 cm e 24 cm a partir do seu eixo de rotação e 5 a 22 cm de altura.

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

A parte de controlo seja ela hardware ou software está descrita, pelo próprio autor (ver links do autor do braço no inicio do artigo) ou em vários projectos em que o robot manipulador EezyBotArm MK2 é usado.

 

Integração do eezyBotArm MK2 com o ROS

https://github.com/SimBil91/coffee-bot

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

https://hotblackrobotics.github.io/it/blog/2018/02/14/sibot-cloud/

https://rospibot.azw.pt/wp-content/uploads/2020/04/eezyarm_APIEMS2019_paper_259.pdf

Braços robóticos EezyBotArm

Os braços robóticos EezyBotArm são uma família de robots manipuladores educativos desenhados com base no robot industrial ABB – IRB 460, pelo italiano Carlo Franciscone.

Até ao momento de escrita deste artigo, esta família já conta com três versões de braços robóticos educativos fáceis de fazer, com instruções e ficheiros stl publicados na Internet.

O mais pequeno, económico, e antigo da família é o EezyBotArm MK1, tem com 3 servos MG90 a mover as hastes e um SG90 a abrir e fechar a garra.

A segunda versão, é o EezyBotArm MK2. Tem com 3 servos MG995 (ou MG946, ou MG966)  a mover as hastes e um SG90 a abrir e fechar a garra.

A terceira versão, o EezyBotArm MK3, passou a usar motores de passo (steppers) como actuadores para posicionamento das hastes, e mantém o servo SG90 como actuador para abrir e fechar a garra.

Para além destes braços desenvolvidos por Carlo Franciscone, existe um remix do EezyBotArm MK2, conhecido por Robot Arm MK2 Plus e que foi redesenhado para usar motores de passo Nema 17.

Os braços desta família não são os únicos desenhados com base no IRB 460. Existem várias edições deste modelo cinemático disponíveis como kits comerciais com destaque para os meArm. 

Cinemática dos braços eezyBotArm

Para além dos componentes mecânicos e actuadores dos braços

Hardware de controlo dos braços robóticos EezyBotArm

Sofware de controlo dos braços robóticos EezyBotArm

 

EezyBotArm MK1

O braço robótico EezyBotArm MK1 é o mais antigo e pequeno da família de robots manipuladores educativos desenhada por Carlo Franciscone.

Os braços robóticos EezyBotArm são de uso didáctico, económicos e facilmente fabricados numa impressora 3D.

O EezyBotArm MK1 que é o mais pequeno e económico da família, destaca-se exactamente pelo seu baixo custo de produção.

Para a impressão e montagem do braço recolhi e publiquei informação em português, incluindo uma lista de materiais actualizada, no artigo sobre como Fazer o braço robótico EezyBotArm MK1.

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

 

Robot Arm MK2 Plus com Limitadores de Curso

Limitadores de Curso para o Robot Arm MK2 Plus.

Os limitadores de curso (endstop switches) para o braço robótico Robot Arm MK2 Plus são feitos com pequenos interruptores aplicados no corpo do robot com suportes impressos em 3D.

Os ficheiros e instruções de montagem estão disponíveis no seguinte endereço:

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

 

Video do posicionamento automático durante o arranque

Pormenores da montagem do limitador de curso no mainarm do robot

Pormenor do limidador de curso do main arm
Limitador de curso do mainarm accionado

Pormenores da montagem do limitador de curso no varm do robot

Pormenor do limitador de curso do varm
Limitador de curso do varm acionado

 

 

Robot Arm MK2 Plus

O braço robótico Robot Arm MK2 Plus é baseado no eezyBotArm MK2, mas com motores de passo (stepper motors) em vez de servos .

O Robot Arm MK2 Plus tem informação original de fabrico disponível nos seguintes endereços:

  • https://www.thingiverse.com/thing:2520572
  • https://www.instructables.com/id/Robot-Arm-MK2-Plus-Stepper-Motor-Used/

Para além da informação original nos endereços acima está também disponível a seguinte informação para o Robot Arm MK2 Plus:

Outras informações

Robot Arm MK2 Plus auto home with endstops switches

Making Robot Arm MK2 Plus

Depois de ter fabricado duas versões do braço robótico eezyBotArm, a MK1 e a MK2 sem ter obtido os resultados desejados, em nenhuma delas tentei uma variante do MK2, encontrei no mesmo site, mas com steppers motors em vez de servos que. O Robot Arm MK2 Plus.

O robot manipulador Robot Arm MK2 Plus tem informação original de fabrico disponível nos seguintes endereços:

  • https://www.thingiverse.com/thing:2520572
  • https://www.instructables.com/id/Robot-Arm-MK2-Plus-Stepper-Motor-Used/

Este artigo tem como objecto a construção do braço do ponto de vista mecanico, incluindo os actuadores. A parte electrónica e o software de controlo não estão contemplados.

Lista de componentes do Robot Arm MK2 Plus (BOM)

Na informação disponível na Internet não descobri a lista de componentes. Esta lista foi o resultado das minhas escolhas. Alguns dos componentes podem ser substituídos por outros.

Componentes comprados para o Robot Arm MK2 Plus

Motores

  • 3 x Mortor de passos (Steppers) Nema 17 – 42HS40
  • 1 x Motor servo Tower Pro SG90

Varão roscado

  • 1 x M4 x 80 mm
  • 1 x M4 x 60 mm

Parafusos

Com excepção do indicado em parafuso específicos, o tipo de cabeça pode ser sextavada, fenda ou Philips.

  • 5 x M3 x 8 mm
  • 8 X M3 x 10 mm (cabeça sextavada externa)
  • 1 x M3 x 15 mm
  • 1 x M3 x 20 mm
  • 2 x M3 x 60 mm
  • 5 x M4 x 20 mm
  • 1 x M4 x 35 mm
  • 1 x M4 x 50 mm
  • 1 x M6 x 25 mm

Porcas

  • 3 x M3
  • 2 x M3 auto-bloqueante
  • 11 x M4 auto-bloqueante
  • 1 x  M6 auto-bloqueante

Anilhas

  • 1 x M6

Esferas

10 x 5 mm (plastico ou metal, tb podem ser impressas)

Componentes impressos em 3D para Robot Arm MK2 Plus

Os ficheiros STL para imprimir os componentes estão disponíveis no endereço acima (thingverse).  Segue uma relação dos componentes  que é necessário imprimir.

Necessários

  • 1 x Base_Arm.STL
  • 1 x Base_Bearing_Holder.STL
  • 1 x EBAmk2_002_mainarm.STL
  • 1 x EBAmk2_003_varm.STL
  • 1 x EBAmk2_004_link135.STL
  • 1 x EBAmk2_005_link135angled.STL
  • 1 x EBAmk2_006_horarm__.STL
  • 1 x EBAmk2_007_trialink.STL
  • 1 x EBAmk2_008_link147_new.STL
  • 1 x EBAmk2_009_trialinkfront.STL
  • 1 x EBAmk2_014_claw_base.STL
  • 1 x EBAmk2_015_claw_finger_dx.STL
  • 1 x EBAmk2_016_claw_gear_drive.STL
  • 1 x EBAmk2_017_claw_finger_sx.STL
  • 1 x EBAmk2_018_claw_gear_driven.STL
  • 1 x gear1.STL
  • 1 x gear2.STL
  • 1 x Robot_Base_Low.STL
  • 1 x Robot_Base_Low_Gear.STL
  • 3 x Stepper_Gear.STL

Opcionais

  • Base_Bearing_Ball.STL (esfera de 5 mm)
  • finalholder.STL

Alternativos

  • claw_finger_long_dx.stl
  • claw_finger_long_sx.stl
  • stepper-screw-spacer.stl (finalholder.STL)

Não necessários

  • EBAmk2_006_horarm_plate.STL
  • EBAmk2_006_horarm__.gcode
  • Robot_Asm.STL (aspecto geral do robot manipulador)
  • screw_holder1.STL
  • screw_holder2.STL
  • Left_gear.STL
  • Base_Bearing_Ball.STL

Montagem do braço manipulador Robot Arm MK2 Plus

Depois de adquiridas e impressas as peças chegou a hora de montar o braço Robot Arm MK2 Plus. O procedimento é relativamente simples. Esta é a minha sugestão de montagem para o braço manipulador.

Montagem da base do braço robótico

Recomendo começar pela montagem da base do braço robótico Robot Arm MK2 Plus. Também se pode montar primeiro os motores de passo (steppers), pois facilita a montagem do stepper 2.

Lista de peças necessárias nesta fase:

  • 1 x Base_Arm
  • 1 x Base_Bearing_Holder
  • 1 x Robot_Base_Low
  • 1 x Robot_Base_Low_Gear
  • 2 x  parafuso M3 x 60 mm
  • 2 x porca M3
  • 1 x parafuso M6 x 25 mm
  • 1 x porca M6 auto bloqueante
  • 10 x esferas de 5 mm

Procedimento de montagem conforme os seguintes passos.

Deve-se proceder à preparação prévia do orifício na base_low de modo a que o parafuso M6 entre sem grande atrito.

Na mesma ordem de ideias deve-se também proceder à preparação prévia dos orifícios da base (Base_Arm) de modo a que os respectivos parafuso M4, ou os varões roscados, entrem sem grande atrito.

1º passo – Coloca-se a porca M6 auto-bloqueante no orifício apropriado na parte de baixo do Base_Arm.

2º passo – Fixa-se o Base_Arm ao Robot_Base_Low com os dois parafusos M3 de 60 mm e as duas porcas M3.

3º passo – Prepara-se o Robot_Base_Low_Gear, com a colocação do Base_Bearing_Holder, e das 10 esferas de 5 mm nos locais apropriados.

4º passo – Aplica-se o conjunto construído no passo 2 (Base_ArmRobot_Base_Low), por cima do conjunto descrito no passo 3 (Robot_Base_Low_Gear + Base_Bearing_Holder + esferas), de modo a que a saliência onde encaixa o para fuso encaixe também no orifício no centro do Robot_Base_Low_Gear. Mantento todo o conjunto estavel, sem deixar cair ou deslocar-se do sitio nenhuma das peças, fixar com o parafuso M6 de 25 mm com a anilha M6. Este parafuso enrosca na porca M6 referida no passo 1.

Montagem dos motores de passo (steppers)

De modo a facilitar a montagem, recomendo montar os motores de passo (steppers) antes da montagem das hastes do manipulador.

Como o suporte para os motores de passo estão fixos ao Base_Arm, tem de se usar parafusos com a cabeça sextavada externa, e a montagem dos motores de passo antes das hastes facilita a sua colocação e aperto. 

Por outro lado, como o eixo dos motores de passo que usei tem 25 mm, os motores 2 e 3 tem os seguintes pormenores:

Motor 2 (traseiro), o eixo prolonga-se para além da distancia (6 mm) permitida pela engrenagem maior da base (Robot_Base_Low_Gear), pelo que é necessário um suporte adicional por baixo dessa base.

Motor 3 (direito), o eixo é maior que o espaço disponível o que impede o encaixe adequado ao suporte vertical sem que sejam aplicados uns espaçadores (stepper-screw-spacer) com cerca de 5.5 mm em cada um dos 4 orifícios.

Lista de peças usadas nesta fase da montagem:

  • 1 x Base_Arm (conjunto montado na fase anterior)
  • 3 x Mortor de passos (Steppers) Nema 17 – 42HS40
  • 4 x parafuso M3 x 8 mm
  • 8 x parafuso M3 x 10 mm (cabeça sextavada externa)
  • 3 x Stepper_Gear
  • 4 x  stepper-screw-spacer (opcional)

Antes de serem montados deve aplicar a cada um dos motores de passo deve ser aplicado a respectiva engrenagem (Stepper_Gear).

A ordem de montagem dos motores de passo, não é importante. O que importa ter em consideração é o seguinte:

No motor 1 e motor 3 usa-se em cada um 4 parafusos M3 de 10 mm com cabeça sextavada externa;

No motor 2 usa-se 4 parafusos M3 de 8 mm e eventualmente 2 anilhas M3 de 1 mm. Na montagem tenha em atenção a posição das engrenagens. Deve posicionar cada uma delas de modo a facilitar a colocação;

No motor 3 caso o eixo seja demasiado longo pode ser necessário aplicar os 4 espaçadores (stepper-screw-spacer).

Caso os parafusos M3 de 10 mm sejam demasiado compridos poderá ser necessário colocar umas porcas M3 a servir de anilha em cada parafuso, ou imprimir 4 anilhas semelhantes ao stepper-screw-spacer mas com 2 mm de espessura.

Montagem das hastes do manipulador

Depois de montada a base e os motores de passo, será a vez de montar as hastes do braço manipulador robótico Robot Arm MK2 Plus.

Lista de peças usadas nesta fase da montagem:

  • 1 x base_arm (ou o conjunto montado nas fases anteriores)
  • 1 x mainarm
  • 1 x varm
  • 1 x link135
  • 1 x link135angled
  • 1 x horarm
  • 1 x trialink
  • 1 x link147
  • 1 x trialinkfront
  • 1 x gear1
  • 1 x gear2
  • 1 x varão roscado M4 x 80 mm
  • 1 x varão roscado M4 x 60 mm
  • 5 x parafuso M4 x 20 mm
  • 1 x parafuso M4 x 35 mm
  • 1 x parafuso M4 x 50 mm
  • 11 x porca M4 auto-bloqueante

Procedimento de montagem conforme os seguintes passos.

Antes de iniciar a montagem seguindo os vários passos descritos nesta fase, deve-se proceder à preparação prévia dos orifícios de todas das hastes de modo a que os respectivos parafuso M4, ou os varões roscados, entrem sem grande atrito.

Na montagem tenha em atenção a posição das engrenagens associadas aos motores de passos (stepper 1 e stepper2). Deve posicionar cada uma delas de modo a facilitar a colocação

1º passo – Prepara-se o conjunto onde actua o motor de passos esquerdo (stepper 1), e que define a altura do end effector. Para o efeito encaixa-se a saliência na engrenagem (gear1) no espaço apropriado da haste (varm). Usar o varão roscado M4 de 80 mm para fixar o conjunto (gear1varm) de modo a que o varão roscado fique apenas ligeiramente saliente face ao orifício da saida na haste pequena (varm). A maior extensão do varão deve estar saliente para o lado da engrenagem.

2º passo – Aplicar a haste vertical (mainarm) no espaço apropriado da base (base arm) e aplicar o conjunto montado no passo anterior (gear1varm + varão roscado), de modo o varão roscado encaixe na abertura da haste principal (mainarm). De seguida pressionar o varão roscado para que avance até ao outro lado da haste principal (de modo a que fique apenas um pouco saliente), passando pelo o orifício da base do braço (base_arm), fixando todo o conjunto de aplicado engrenagens e hastes. Neste passo tenha em conta  posição dos dentes de ambas as engrenagens de forma a facilitar o encaixe.

3º passo – Encaixar o a saliência da engrenagem (gear2) no espaço apropriado na haste principal (mainarm), e o respectivo orifício ao varão roscado (que deve estar apenas um pouco saliente para facilitar a fixação). De seguida  e pressionar o varão roscado de modo a que ele fique um pouco saliente face ao exterior das duas engrenagens. Com o varão roscado na posição adequada enroscar duas porcas M4 auto-bloqueantes em ambas a extremidades do varão roscado. Neste passo tenha em conta  posição dos dentes de ambas as engrenagens de forma a facilitar o encaixe.

4º passo – Encaixar a haste horizontal (horarm) no encaixe superior da haste principal (mainarm) e inserir o varão roscado (M4 x 60mm) nos respectivos orifícios de forma a que o varão não saia pelo outro lado. De seguida aplicar o triângulo (trialink), ao espaço em vazio no topo da haste principal e pressionar o varão roscado de modo a que ele fique um pouco saliente face ao exterior da haste horizontal e à do triângulo. Com o varão roscado na posição adequada enroscar duas porcas M4 auto-bloqueantes em ambas a extremidades do varão roscado.

5º passo – Aplicar, pelos orifícios na extremidades, a haste secundária de controlo da posição vertical do end-efector (link135) ao orifício da haste (varm) na sua face interna, e ao orifício traseiro da haste horizontal (horarm), na sua face externa; com 2 parafusos M4 de 20 mm e porcas M4 auto bloqueantes (em cada orifício, um de cada).

6º passo – Aplicar, pelos orifícios na extremidades, a haste vertical de controlo da horizontalidade do end-efector (link135angled) ao orifício da haste fixa traseira da base (base_arm) na sua face interna e ao orifício traseiro do triângulo (trialink) na sua face interna, com 2 parafusos M4 de 20 mm e porcas M4 auto bloqueantes (em cada orifício, um de cada).

7º passo – Aplicar a haste horizontal de controlo da horizontalidade do end-efector (link147) ao orifício frontal do triângulo (trialink) na sua face interna, com 1 parafuso M4 de 20 mm e 1 porca M4 auto bloqueantes.

8º passo – Aplicar o triângulo frontal (trialinkfront), usado para fixar o end effector, no encaixe existente na extremidade frontal da haste horizontal (horarm) com 1 parafuso M4 de 35 mm e 1 porca M4 auto bloqueantes. De seguida, aplicar a haste horizontal de controlo da horizontalidade do end-efector (link147) ao orifício superior do triângulo frontal com 1 parafuso M4 de 50 mm e 1 porca M4 auto bloqueantes.

Montagem e aplicação da garra (end effector)

Depois de montada a base, os motores de passo, e as hastes será a vez de montar ao end effector (garra) do braço manipulador robótico Robot Arm MK2 Plus.

Lista de peças usadas nesta fase da montagem:

  • 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
  • 1 x parafuso M3 com 8 mm
  • 1 x parafuso M3 com 15 mm
  • 1 x parafuso M3 com 20 mm
  • 1 x porca M3
  • 2 x porca M3 auto-bloqueante
  • 2 x parafuso para montar servo
  • 1 x parafuso para montar suporte no eixo do servo

Nota: esta descrição de montagem foi adaptada da previamente efectuada para o eezyBotArm MK2.

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 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 15 mm,  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 8 mm e uma porca M3.

O end efector pode ser substituido por outros modelos, que sejam compativeis com o eezyBotArm MK2

Firmware para controlo de braços robóticos com ROS moveit

O firmware para controlo de braços robóticos com ROS não é especifico para o moveit.

O controlo é relativamente fácil e envolve dois nodes, e dois tópicos.

Um node ROS localizado num computador, subscreve o tópico /joint_states, com mensagens do tipo sensor_msgs/JointState, e depois de converter cada uma das mensagens (no tipo de dados adequado) publica mensagens no tópico subscrito pelo node rosserial a ser executado como firmware no micro- controlador responsável pelo controlo directo dos motores do braço.

O tipo de dados necessário para conduzir os motores pode variar conforme os motores usados, (servos ou steppers)  mas regra geral será um array de inteiros com a posição em graus que cada um dos motores do braço robótico deve ter a cada momento.

Exemplos do firmware usado num microcontrolador adequado ao ros moveit, ou de forma genérica a outro processo de controlo de braços robóticos pode ser encontrado no seguinte repositório:

https://github.com/inaciose/ntbd_firmware

 

Exemplo de node ROS em python que subscreve um tópico Float64 e publica mensagens no topico /joint_states.

import rospy  
from sensor_msgs.msg import JointState
from std_msgs.msg import Float64


class CommandToJointState:
    def __init__(self):
        self.joint_name = rospy.get_param("~joint_name")
        self.joint_state = JointState()
        self.joint_state.name.append(self.joint_name)
        self.joint_state.position.append(0.0)
        self.joint_state.velocity.append(0.0)
        self.joint_pub = rospy.Publisher("joint_states", JointState, queue_size=1)
        self.command_sub = rospy.Subscriber("command", Float64,
                                            self.command_callback, queue_size=1)

    def command_callback(self, msg):
        self.joint_state.position[0] = msg.data
        self.joint_state.header.stamp = rospy.Time.now()
        self.joint_pub.publish(self.joint_state)

if __name__ == '__main__':
    rospy.init_node('command_to_joint_state')
    command_to_joint_state = CommandToJointState()
    rospy.spin()

fonte:

https://answers.ros.org/question/276405/how-to-write-my-own-joint-state/

 

ntbd eezybotarm mk2

Este artigo é sobre a exploração do projecto genérico para controlo de braços robóticos em ROS com o nome NTBD, cujo o exemplo de implementação é feico com o eezybotarm mk2, e que está descrito no seguinte endereço:

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

Para além desta descrição existe também um repositório no github com o software usado na implementação do controlo do braço robótico eezybotarm mk2 no ROS e que está disponível nos seguintes endereços (o segundo é o meu fork)

  • https://github.com/HotBlackRobotics/ntbd
  • https://github.com/inaciose/ntbd

A exploração do software neste repositório será feita de dois modos:

  • Numa primeira fase em conformidade com o procedimento descrito no artigo principal, onde se recorre ao um container do docker pré preparado pelo autor do projecto.
  • Numa segunda fase será abordado de forma nativa de modo a compreender melhor o funcionamento de cada um dos pacotes.
  • Numa terceira fase, irei alterar o hardware de controlo dos servos passando a usar uma placa de geração de sinais PWM com interface i2c baseada no chip PCA9685.

As duas primeiras fases partilham o mesmo hardware descrito no projecto ntbd, ainda sem o modulo PCA9865.

Hardware de controlo do braço robótico

Para além de um braço robótico adequado, o projecto ntbd usa como exemplo o eezibotarm mk2, mas pode ser aplicado noutros braços robóticos como por exemplo o eezibotarm mk1. é  necessário o seguinte hardware:

  • Um micro-controlador. O controlo dos servos pode ser efectuado por um micro-controlador, como por exemplo o ATMEGA 328p. Seguindo o projecto ntbd, será usado um Arduino Mega 2560.
  • Um computador com linux capaz de correr o docker e o ROS. Pode ser um PC x86 ou Raspberry Pi. Na segunda fase o computador tem de ter o ROS instalado.

As ligações entre o arduino e os servos são as seguintes:

  • Servo 1 sinal (amarelo) > Arduino pino 2
  • Servo 2 sinal (amarelo) >Arduino pino 3
  • Servo 3 sinal (amarelo) > Arduino pino 4
  • Servo 4 sinal (amarelo) > Arduino pino 5

Podem ser usados outros pinos, desde que seja capazes de produzir um sinal PWM, mas para isso é necessário alterar o firmware.

Os servos devem ter alimentação externa. Não esquecer de partilhar a terra.

A ligação entre o computador e o Arduino é efectuada por uma interface USB.

Firmware de controlo do braço robótico

Microcontrolador  tem que estar a correr um programa desenhado para o efeito.

No firmware original do ntbd, a integração no ROS  é efectuda pelo recurso às bibiotecas rosserial, e para gerar o sinal PWM adequado é usada a biblioteca Servo. 

O programa é bastante simples, mas o procedimento para a compilação é mais elaborado, e está descrito no seguinte artigo:

NTBD Robot Arm Arduino Firmware

Numa fase posterior será usado um modulo PCA9685, pelo que o firmware terá de ser alterado para o novo hardware.

Exploração do NTBD com Docker Containers

O autor do projecto NTBD preparou dois docker containers com os pacotes para o ROS para serem usados no projecto ntbd docker.

  • O container o ntbd_base, contém os pacotes globais (ntbd_core e ntbd_msgs);
  • O container ntbd_manipulator, contém o software especifico para o braço robótico. Neste caso o eezybotarm mk2.

Para além do software nos docker containers é ainda necessário proceder à preparação de um micro controlador, um Arduino Mega, com o firmware referido acima.

Para saber mais sobre o assunto consultar:

Explorar o eezyBotArm mk2 com NTBD Docker Container.

Exploração do NTBD sem docker

Exploração do software existente no repositório do ntbd no github de forma proceder á sua execução fora do docker.

Na base do repositório existem duas pastas. A pasta ntdb_base tem dois pacotes para o ROS que funcionam independentemente o braço robótico que está a ser explorado. Além desses dois pacotes tem ainda um ficheiro de configuração para o nginx. A pasta ntbd_manipulator tem o software especifico para um braço robótico, no caso o eezybotarm mk2, e o software para ser executado no webserver.

Para além dos pacotes do ros, e o software web, o respositório tem também o sketch para o arduino que subscreve o tópico motors do tipo Motors_Array, via rosserial.

ntbd_core

Existente dentro da pasta ntbd_base, é um pacote genérico que se encarrega do movimento dos servos com os seguintes com os seguinte scripts:

  • motors_limiter, publica o tópico motors, e subscreve o motors_nolim;
  • path_planner, publica o tópico desired_position, e subscreve o desired_position_nointerp;
  • position_limiter, publica o tópico desired_position_nointerp, e subscreve o desired_position_nolim;

ntdb_msgs

Existente dentro da pasta ntbd_base, é um pacote genérico que contém a definição das mensagens do tipo  Motors_Array

urdf_manipulator

Existente dentro da pasta ntbd_manipulator, é um pacote especifico para braço robótico, e  tem as pastas de config, launch, meshes e urdf.

Este pacote esta dentro de uma pasta que a refere como abstrata.

Também na pasta ntbd_manipulator, e fora de qualquer pacote do ROS, estão os seguintes ficheiros:

  • fk, publica o tópico actual_position, e subscreve o motors
  • ik, publica o tópico motors_nogripper, e subscreve o desired_position
  • motors_values, publica o tópico motors_nolim, e subscreve os tópicos: gripper_value e motors_nogripper
  • physical_2_visual, publica o tópico joint_states, e subscreve o motors

Também de fora de qualquer pacote do ROS está o ficheiro NTBD_launch.launch.

Todos estes ficheiros tem de ser copiados para dentro de um pacote do ROS para poderem ser executados. Se usarmos o ficheiro launch NTBD_launch.launch, sem modificações, todos os ficheiros tem de ser copiados para o pacote ntbd_core.

O ficheiro NTBD_launch.launch tem um erro, pois refere o ficheiro siBOT_noEE.urdf na pasta robots, quando ele está na pasta urdf.

O projecto implica a instalação de alguns pacotes do sistema e do ROS caso não estejam previamente instalado com os seguintes comandos:

sudo apt install nginx
sudo apt install ros-melodic-rosbridge-server
sudo apt install ros-melodic-rosbridge-suite
sudo apt install ros-melodic-tf2-web-republisher

Por último, já depois de ter copiado os scripts e o launch para o sitio certo, ter configurado o nginx, colocado o conteúdo da pasta web na pasta apropriada, e ter efectuado algumas alterações ao ficheiro launch efectuei a primeira tentativa de executar o ntbd fora do docker com o seguinte comando:

roslaunch manipulator_urdf NTBD_launch.launch

Com os pacotes do ntdb em execução é necessário apontar navegador para o endereço seguinte:

http://localhost

Mas as coisas não funcionaram pois, não visualizo o braço no interface web, conforme acontece quando se usa a versão do docker, e quando tento executar o interface web de controlo do braço dá-me sempre este erro:

2020-04-12 22:12:16+0100 [-] failing WebSocket opening handshake (‘missing port in HTTP Host header ‘localhost’ and server runs on non-standard port 9090 (wss = False)’)
2020-04-12 22:12:16+0100 [-] dropping connection to peer tcp4:127.0.0.1:33722 with abort=False: missing port in HTTP Host header ‘localhost’ and server runs on non-standard port 9090 (wss = False)

Nos seguintes links recolhi alguma informação sobre o assunto mas não consegui resolver o problema:

https://github.com/crossbario/autobahn-python/issues/775

https://github.com/RobotWebTools/rosbridge_suite/issues/467

Após analisar o index.html descobri que o interface fica funcional se alterar a linha 186 para o seguinte:

url : ‘ws://’+ window.location.hostname + ‘:9090’

Após este teste bem sucedido irei preparar dois pacotes ROS adequados a exploração dos braços eezybotarm mk1 e mk2 fora do docker.

Tópicos dos nodes usados pelo ntbd

  • /actual_position (pub: FK)
  • /client_count (pub: rosbridge_websocket)
  • /connected_clients (pub: rosbridge_websocket)
  • /desired_position (pub: path_planner; sub: IK)
  • /desired_position_nointerp (pub: position_limiter; sub: path_planner)
  • /desired_position_nolim (pub: rosbridge_websocket; sub: position_limiter);
  • /diagnostics (pub: init_serial_node)
  • /gripper_value (pub: rosbridge_websocket; sub: motors_values)
  • /joint_states (pub: joint_state_publisher_gui, physical_2_visual; sub: robot_state_publisher)
  • /motors (pub: motors_limiter; sub: FK, physical_2_visual, init_serial_node)
  • /motors_nogripper (pub: IK; sub: motors_values)
  • /motors_nolim (pub: motors_values; sub: motors_limiter)
  • /tf (pub: robot_state_publisher; sub:  tf2_web_republisher)
  • /tf2_web_republisher/cancel (pub: rosbridge_websocket; sub: tf2_web_republisher)
  • /tf2_web_republisher/feedback (pub: tf2_web_republisher; sub: /rosbridge_websocket)
  • /tf2_web_republisher/goal(pub: rosbridge_websocket; sub: tf2_web_republisher)
  • /tf2_web_republisher/result (pub: tf2_web_republisher; sub: /rosbridge_websocket)
  • /tf2_web_republisher/status(pub: tf2_web_republisher; sub: /rosbridge_websocket)
  • /tf_static (pub: robot_state_publisher; sub: tf2_web_republisher)

 

NTBD Arduino Firmware

O firmware a correr no Arduino integra-se no ROS  pelo recurso às bibliotecas rosserial,  e, numa primeira fase, para gera o sinal PWM adequado é usada a biblioteca Servo. 

Posteriormente o sinal PWM será gerado por um módulo PCA9685, e o firmware necessita de ser alterado.

O arduino mega 2560 deve estar a correr o programa: myServoControl_ntbd.ino, que se encontra disponível no repositório ntdb do github.

O programa requer que a biblioteca ros_lib (rosserial arduino) esteja instalada no Arduino IDE.  A biblioteca rosserial pode ser instalada no gestor de bibliotecas disponível no IDE, mas é recomendado usar a biblioteca gerada pelo rosserial-arduino.

Também é obrigatório ter instalados no computador os pacotes do ROS:  rosserial e rosserial arduino. Para instalar pode-se usar os seguintes comandos:

sudo apt install ros-melodic-rosserial
sudo apt install ros-melodic-rosserial-arduino

Como o programa para o Arduino requer mensagens personalizadas do ROS  (ROS custom messages). Ver linha:

#include <ntbd_msgs/Motors_Array.h>

Teremos que efectuar um procedimento especial, que envolve a compilação do pacote de ROS do ntbd que tem as mensagens personalizadas, e assim obter o ficheiro de header necessário.

Para obter o ficheiro Motors_Array.h, é necessário, antes de mais, colocar o respectivo pacote do ROS na pasta adequada do catkin e proceder á sua compilação (também se pode proceder clonagem de todo o repositório postrior compilação):

cd ~/catkin_sw/src
git clone https://github.com/HotBlackRobotics/ntbd
cd ~/catkin_sw
catkin_make

De seguida, tem de se usar um dos seguintes comandos (pelos vistos existe a informação de vários devido à evolução das várias versões do ROS):

No ROS Melodic, o comando que funcionou foi  o ultimo dos indicados abaixo.

rosrun rosserial_client make_library.py ~/ ntbd_msgs
rosrun rosserial_arduino make_library.py ~/ ntbd_msgs
rosrun rosserial_arduino make_libraries.py ~/ ntbd_msgs

~/ representa a pasta de destino onde se encontra a ros_lib (biblioteca rosserial para o arduino)

ntbd_msgs, indica o pacote (com as mensagens) a ser compilado

O comando que usei (o último) gerou uma pasta ros_lib na home com toda a biblioteca do rosserial incluindo uma pasta ntbd_msgs que contem o ficheiro pretendido.

Nesta fase podemos optar por uma das duas soluções:

  • Copiar a pasta ~/ros_lib/ntbd_msgs para ~/Arduino/libraries/ros_lib;
  • Copiar a pasta para dentro da pasta do sketch do arduino, e alterar uma linha de include para passar a incluir a biblioteca localmente: #include “ntbd_msgs/Motors_Array.h”

Nesta fase já podemos compilar e enviar o programa para o Arduino Mega.

Sem alteração da biblioteca a comunicação serial funciona a 57600, por isso é necessário proceder, conforme descrito nos comentários do programa, à alteração a um ficheiro da biblioteca ros_lib.

myServoControl_ntbd.ino

Versão 1 (original)

Nesta versão é usado apenas o micro-controlador (arduino)

/* NTBD integration with eezybotarm
* Servo motors control using rosserial
* Author: fiorella.sibona@gmail.com
*/

#include <Servo.h> 
#include <ros.h>
#include <ntbd_msgs/Motors_Array.h>
#define USE_USBCON

ros::NodeHandle nh;

Servo servo1, servo2, servo3, servo4;

// Callback funtion ("as message is read, perform these actions")
void servos_cb( const ntbd_msgs::Motors_Array& angles_msg){

servo1.write(angles_msg.data[0]); 
servo2.write(angles_msg.data[1]);
servo3.write(angles_msg.data[2]);
servo4.write(angles_msg.data[3]);

}

// Subscriber node declaration, specifies the topic to which subscribe and the callback funtion
ros::Subscriber<ntbd_msgs::Motors_Array> sub("motors", servos_cb);

// Arduino setup function
void setup(){

nh.initNode();
nh.subscribe(sub);

servo1.attach(2); //attach it to pin 2
servo2.attach(3);
servo3.attach(4);
servo4.attach(5);

}

// Arduino loop function
void loop(){

nh.spinOnce();
delay(1);

}

 

Referencias

http://wiki.ros.org/rosserial_arduino/Tutorials/Adding%20Custom%20Messages

https://medium.com/@Sammy_Hasan/quick-code-v0-3-rosserial-custom-messages-ebdfc7ea172e