RoboGlove: 12 etapas (com imagens)

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

Somos um grupo de alunos da ULB, Université Libre de Bruxelles. Nosso projeto consiste no desenvolvimento de uma luva robótica capaz de criar uma força de preensão ajudando as pessoas a agarrarem coisas.

A LUVA

A luva tem uma conexão de fio que liga os dedos a alguns servo motores: um fio é preso à extremidade do dedo e ao servo, então quando o servo gira, o fio é puxado e o dedo flexionado. Desta forma, ao controlar a preensão feita pelo usuário através de alguns sensores de pressão na extremidade dos dedos, podemos acionar os motores de forma controlada e auxiliar na preensão dobrando o dedo proporcionalmente à rotação dos motores e então para o enrolamento dos fios. Desta forma, devemos ser capazes de permitir que pessoas fracas agarrem objetos ou mesmo ajudar pessoas em condições fisiológicas a agarrar objetos e mantê-los sem nenhum esforço.

O DESIGN

O modelo foi desenvolvido de forma a tornar o movimento da mão o mais livre possível. Na verdade, imprimimos em 3D apenas as peças estritamente necessárias para conectar fios, motores e dedos.

Temos uma cúpula superior impressa em PLA em cada dedo: esta é a parte terminal onde os fios devem ser conectados e deve dar proteção ao sensor de pressão que é fixado em seu interior. O sensor de pressão é colado, com cola quente, entre a extremidade do PLA e a luva.

Então temos dois anéis impressos em 3D, por dedo, que constituem um guia para os fios. O polegar é o único dedo que possui apenas um anel impresso. Existe um fio por dedo, dobrado ao meio na extremidade dos dedos. As duas metades estão passando pelas duas guias da parte da cúpula e em ambos os anéis: são colocadas diretamente nos orifícios que fizemos na parte externa desses anéis. Em seguida, eles são colocados juntos em uma roda conectada diretamente ao motor. A roda foi realizada de forma a poder envolver os fios: como o nosso motor tem uma rotação incompleta (inferior a 180 °) realizamos a roda para puxar o fio por um vão de 6 centímetros que é a distância precisava fechar completamente a mão.

Também imprimimos duas placas para fixar os servo motores e o arduino ao braço. Deve ser melhor cortá-lo em madeira ou plástico rígido com um cortador a laser.

Etapa 1: lista de compras

Luva e fios:

1 luva existente (deve ser costurável)

Jeans velhos ou outro tecido rígido

Fios de nylon

Tubulação de polietileno de baixa densidade (Diâmetro: 4 mm Espessura: 1 mm)

Eletrônicos:

Arduino Uno

1 bateria 9V + 9V porta-bateria

1 interruptor eletrônico

1 veroboard

3 servo motores (1 por dedo)

3 hélices (fornecidas com os servos)

4 pilhas AA + 4 porta pilhas AA

3 sensores de pressão (1 por dedo)

3 resistores de 330 ohms (1 por dedo)

6 fios elétricos (2 por sensores)

Parafusos, porcas e fixações:

4 M3 de 10 mm de comprimento (para consertar o Arduino)

2 M2,5 12 mm de comprimento (para fixar o suporte da bateria de 9V)

6 nozes correspondentes

6 M2 de 10 mm de comprimento (2 por servo para fixar as rodas aos servos)

12 pequenas abraçadeiras (para fixar as placas e o interruptor)

7 abraçadeiras grandes (2 por motores e 1 para o suporte de 4 baterias AA)

Ferramentas usadas:

Impressora 3D (Ultimaker 2)

Material para costura

Pistola de cola quente

Opcional: cortador a laser

Etapa 2: preparar a estrutura vestível

A estrutura vestível foi feita com algumas roupas: no nosso caso usamos uma luva normal para eletricista e um pano jeans para a estrutura ao redor do pulso. Eles foram costurados juntos.

O objetivo é ter uma estrutura usável flexível.

A estrutura tem de ser mais forte do que uma luva de lã normal, uma vez que tem de ser cosida.

Precisamos de uma estrutura vestível ao redor do pulso para segurar os fornecedores de energia e os atuadores, e precisamos que ela seja estável, então optamos por fazer o fechamento ajustável aplicando faixas de velcro (faixas autoadesivas) no pulso do jeans.

Alguns palitos de madeira foram costurados por dentro para tornar o jeans mais rígido.

Etapa 3: preparar as peças funcionais

As peças rígidas são realizadas através de impressão 3D em PLA a partir dos arquivos.stl na descrição:

Anel de dedo x5 (com escalas diferentes: escala 1x 100%, escala 2x 110%, escala 2x 120%);

Extremidade do dedo x3 (com escalas diferentes: escala 1x 100%, escala 1x 110%, escala 1x 120%);

Roda para motor x3

Para as partes dos dedos, escalas diferentes são necessárias devido ao tamanho diferente de cada dedo e de cada falange.

Etapa 4: fixe os sensores nas extremidades

Os sensores de pressão são soldados primeiro aos fios do cabo.

São então colados com o uso de uma pistola de cola dentro das extremidades dos dedos: uma pequena quantidade de cola é colocada dentro da extremidade, do lado com os dois orifícios, então o sensor é imediatamente aplicado com a parte ativa (redonda) na cola (coloque o piezoelétrico voltado para o interior da estrutura e a parte plástica diretamente na cola). Os fios do cabo devem passar do topo do dedo até as costas, para que o cabeamento elétrico passe nas costas da mão.

Etapa 5: fixe as peças impressas em 3D na luva

Todas as partes rígidas (extremidades, anéis) devem ser costuradas na luva para serem fixadas.

Para colocar os anéis corretamente, use primeiro a luva e tente colocar os anéis, um por falange, sem que eles se toquem durante o fechamento da mão. Aproximadamente, os anéis no índice serão fixados 5mm acima da base do dedo e 17 a 20mm acima do primeiro. Em relação ao dedo médio, o primeiro anel ficará aproximadamente 8 a 10mm acima da base do dedo, e o segundo cerca de 20mm acima do primeiro. No que diz respeito ao polegar, a precisão necessária é muito baixa, pois não corre o risco de interferir nos outros anéis, por isso tente aplicá-la na luva gasta, desenhe uma linha na luva onde prefere que o anel para que você possa costurá-lo.

Em relação à costura, nenhuma técnica ou habilidade particular é necessária. Com uma agulha, a linha de costura faz círculos ao redor dos anéis, passando pela superfície da luva. Um passo de 3-4mm entre dois furos na luva já dá uma fixação bastante forte, não há necessidade de fazer uma costura muito densa.

A mesma técnica é aplicada para fixar as extremidades: o topo da extremidade é furado para fazer a agulha passar facilmente, então apenas as formas em cruz no topo do dedo terão que ser costuradas na luva.

Em seguida, as guias de polietileno também devem ser fixadas, seguindo três critérios:

a extremidade distal (voltada para o dedo) deve ficar voltada na direção do dedo, para evitar atritos elevados com o fio de náilon que vai passar por dentro;

a extremidade distal deve estar longe o suficiente para não interferir no fechamento da mão (cerca de 3cm abaixo da base do dedo é bom o suficiente, 4 a 5cm para o polegar);

os tubos devem passar o menos possível entre si, para reduzir o volume de toda a luva e a mobilidade de cada tubo

São fixados por costura à luva e ao pulso, com a mesma técnica anterior.

Para evitar qualquer risco de deslizamento pela costura, um pouco de cola foi adicionada entre os tubos e as luvas.

Etapa 6: Prepare as rodas para os servos

Para este projeto, usamos rodas desenhadas especificamente, desenhadas e impressas em 3D por nós mesmos (arquivo.stl na descrição).

Uma vez impressas as rodas, temos que fixá-las às hélices dos servos aparafusando (parafusos M2, 10mm). Como os furos das hélices são menores que 2 mm de diâmetro, aparafusando o M2, não são necessárias porcas.

As 3 hélices podem ser aplicadas em cada servo.

Etapa 7: Fixar os motores no braço

Esta etapa consiste na fixação dos motores ao braço; para isso tivemos que imprimir uma placa de PLA auxiliar para conseguir um suporte.

Na verdade, os motores não podiam ser fixados diretamente no braço, pois as rodas, necessárias para puxar os fios, podiam ficar bloqueadas durante o movimento por causa da luva. Então imprimimos em 3D uma placa de PLA de dimensão 120x150x5 mm.

Em seguida, fixamos a placa na nossa luva com algumas braçadeiras: fizemos alguns furos na luva simplesmente com uma tesoura, depois fizemos furos na placa de plástico com uma broca e montamos tudo. Quatro furos na placa são necessários no centro, entre seu perímetro, para passar as braçadeiras. Eles são feitos com uma broca. Estes ficam na parte central e não nas laterais da placa para poder fechar o jeans ao redor do braço sem que a placa o bloqueie, pois a placa não é flexível.

Em seguida, outros orifícios também são feitos na placa de plástico para fixar os motores. Os motores são fixados com duas braçadeiras cruzadas. Um pouco de cola foi adicionado nas laterais para garantir a fixação.

Os motores devem ser colocados de forma que as rodas não interfiram umas nas outras. Portanto, são separados no lado esquerdo e direito da mão: dois de um lado, com as rodas girando em direções opostas e uma do outro lado.

Etapa 8: Código no Arduino

O código foi desenvolvido de forma simples: acionar ou não os motores. Os servos só são acionados se a leitura estiver acima de um determinado valor (foi corrigido por tentativas e erros porque a sensibilidade de cada sensor não é exatamente a mesma). Existem duas possibilidades de flexão, humilde para uma força baixa e completamente para uma força forte. Depois que o dedo é dobrado, nenhuma força do usuário é necessária para mantê-lo na posição real. A razão desta implementação é que, caso contrário, foi mencionado que os dedos precisam aplicar continuamente uma força nos sensores e a luva não dá nenhuma vantagem. Para liberar a flexão do dedo, uma nova força precisa ser aplicada no sensor de pressão, atuando como um comando de parada.

Podemos dividir o código em três partes:

Sensores init:

Em primeiro lugar, inicializamos três variáveis inteiras: leitura1, leitura2, leitura3 para cada sensor. Os sensores foram colocados nas entradas analógicas A0, A2, A4. Cada variável para a leitura é definida como:

• lendo1 onde está escrito o valor lido na entrada A0,
• leitura2 onde está escrito o valor lido na entrada A2,
• leitura3 onde está escrito o valor lido na entrada A4

Dois limiares são fixados por dedo correspondendo às duas posições de atuação dos servos. Esses limites são diferentes para cada dedo, pois a força aplicada não é a mesma para cada dedo e a sensibilidade dos três sensores não é exatamente a mesma.

Inicialização de motores:

Três variáveis char (save1, save2, save3), uma para cada motor são inicializadas em 0. Então na configuração especificamos os pinos onde conectamos os motores respectivamente: pino 9, pino 6 e pino 3 para servo1, servo2, servo3; todos inicializados com o valor 0.

Em seguida, os servos são acionados através do comando servo.write () que é capaz de fixar o ângulo recebido como entrada no servo. Também por tentativas e erros foram encontrados os dois bons ângulos, necessários para dobrar o dedo em duas posições correspondentes a uma pegada pequena e uma pegada grande.

Como um motor precisa girar na direção oposta devido à sua fixação, seu ponto de partida não é zero, mas o ângulo máximo e diminui quando uma força é aplicada para poder girar na direção oposta.

Link entre sensores e motores:

A escolha de save1, save2, save3 e reading1, reading2, reading3 depende da soldagem. Mas para cada dedo, o sensor e o motor relacionado devem ter o mesmo número.

Em seguida, no loop, se as condições foram usadas para testar se o dedo já está na posição de flexão ou não e se a pressão é aplicada ou não nos sensores. Quando os sensores retornam um valor, uma força precisa ser aplicada, mas dois casos diferentes são possíveis:

• Se o dedo ainda não estiver dobrado, comparando este valor retornado pelos sensores aos limites, o ângulo correspondente é aplicado ao servo.
• Se o dedo já estiver dobrado, significa que o usuário deseja liberar a dobra e então o ângulo inicial é aplicado aos servos.

Isso é feito para cada motor.

Em seguida, adicionamos um atraso de 1000 ms para evitar testar com muita frequência os valores dos sensores. Se um valor de retardo muito pequeno for aplicado, corre-se o risco de reabrir diretamente a mão após fechá-la, caso a força seja aplicada durante um tempo maior do que o tempo de retardo.

Todo o processo para um sensor é apresentado no fluxograma aqui acima.

O CÓDIGO INTEIRO

#include Servo servo1; Servo servo2; Servo servo3; int reading1; int reading2; int reading3; char salvar1 = 0; // o servo começa no estado 0, estado de repouso char save2 = 0; char salvar3 = 0; configuração de vazio (vazio) {Serial.begin (9600); servo2.attach (9); // servo no pino digital 9 servo2.write (160); // ponto inicial para servo servo1.attach (6); // servo no pino digital 6 servo1.write (0); // ponto inicial para servo servo3.attach (3); // servo no pino digital 3 servo3.write (0); // ponto inicial para servo

}

loop vazio (vazio) {leitura1 = analogRead (A0); // anexado a analog 0 reading2 = analogRead (A2); // anexado a analog 2 reading3 = analogRead (A4); // anexado ao analógico 4

// if (reading2> = 0) {Serial.print ("Sensor value ="); // Exemplo de comando usado para a calibração dos limites do primeiro sensor

// Serial.println (leitura2); } // else {Serial.print ("Valor do sensor ="); Serial.println (0); }

if (reading1> 100 and save1 == 0) {// se o sensor obtiver um valor alto e não estiver no estado de hibernação save1 = 2; } // vai para o estado 2 else if (reading1> 30 and save1 == 0) {// se o sensor obtém um valor médio e não está no estado de hibernação save1 = 1; } // chegou ao estado 1 else if (reading1> 0) {// se o valor não é zero e nenhuma das condições anteriores está correta save1 = 0;} // vai para o estado de hibernação

if (salvar1 == 0) {servo1.write (160); } // libera else if (save1 == 1) {servo1.write (120); } // ângulo médio de puxar else {servo1.write (90); } // ângulo máximo de tração

if (reading2> 10 and save2 == 0) {// mesmo que servo 1 save2 = 2; } else if (reading2> 5 and save2 == 0) {save2 = 1; } else if (reading2> 0) {save2 = 0;}

if (salvar2 == 0) {servo2.write (0); } else if (save2 == 1) {servo2.write (40); } else {servo2.write (60); }

if (reading3> 30 and save3 == 0) {// mesmo que servo 1 save3 = 2; } else if (reading3> 10 and save3 == 0) {save3 = 1; } else if (reading3> 0) {save3 = 0;}

if (save3 == 0) {servo3.write (0); } else if (save3 == 1) {servo3.write (40); } else {servo3.write (70); } atraso (1000); } // espere um segundo

Etapa 9: consertar o Arduino, as baterias e o Veroboard no braço

Outra placa foi impressa em PLA para poder fixar os porta-baterias e o arduino.

A placa tem as dimensões: 100x145x5mm.

Quatro furos estão presentes para aparafusar o arduino e dois para aparafusar o suporte da bateria de 9V. Foi feito um furo no suporte da bateria de 6V e na placa para usar uma braçadeira para fixá-los juntos. Foi adicionada cola para garantir a fixação deste suporte. O switch é fixado com duas pequenas braçadeiras.

Existem também quatro furos usados para fixar a placa no jeans por meio de braçadeiras.

O veroboard é colocado no arduino como um escudo.

Etapa 10: conectar os eletrônicos

O circuito é soldado no veroboard conforme relatado no esquema acima.

O Arduino tem uma bateria de 9V como fonte e um interruptor é conectado entre eles para poder desligar o Arduino. Uma bateria de 6V é necessária para o servo motor que precisa de muita corrente e o terceiro pino dos servos é conectado no pinos 3, 6 e 9 para controlá-los com PWM.

Cada sensor é conectado de um lado pelos 5V do Arduino e do outro lado por um resistor de 330 ohms conectado ao solo e pelos pinos A0, A2 e A4 para medir a tensão.

Etapa 11: adicione os fios de nylon

Os fios de náilon são feitos para passar pelos dois orifícios da extremidade e pelos anéis como visto na foto, então as duas metades do fio vão ambas para dentro da guia de polietileno e permanecem juntas até o final da guia, para o motor. O comprimento dos fios é determinado neste ponto, eles precisam ser longos o suficiente para circundar a roda do servo com os dedos retos.

São fixados nas rodas com um nó que passa por dois pequenos orifícios presentes nas limas.stl e com cola quente para estabilização adicional.

Etapa 12: Divirta-se

Funciona como esperado.

No primeiro impulso ele dobra o dedo e no segundo ele o libera. Nenhuma força é necessária quando os dedos estão dobrados.

No entanto, três problemas permanecem:

- Temos que ter o cuidado de dar um impulso menor que 1 segundo para acionar os servos, caso contrário os fios são liberados imediatamente após a puxada conforme explicado no passo 8 sobre o código do Arduino.

- As partes plásticas estão um pouco escorregadias, então colocamos um pouco de cola quente nas extremidades para aumentar a fricção.

- Se uma carga pesada estiver no dedo o sensor terá o tempo todo um valor grande e assim o servo girará continuamente.