Robô de desenho tátil: 5 etapas (com imagens)

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

Como parte da minha graduação de mestrado no dep. Desenho industrial na Universidade de Eindhoven, criei um dispositivo de desenho háptico que pode ser usado para conduzir um carro semiautônomo no trânsito. A interface é chamada de rabisco e permite que o usuário experimente acessórios hápticos em um espaço 2D por meio de força e localização variáveis. Embora o conceito não seja o assunto deste instrutível, você pode ler mais sobre Scribble aqui:

O Scribble usa uma configuração de ligação de 5 barras que permite mover dois graus de liberdade laterais (DoF). Esta configuração é bastante popular entre os prototipadores para criar robôs de desenho. Aqui estão alguns exemplos:

www.projehocam.com/arduino-saati-yazan-kol-…

blogs.sap.com/2015/09/17/plot-clock-weathe…

www.heise.de/make/meldung/Sanduhr-2-0-als-Bausatz-im-heise-shop-erhaeltlich-3744205.html

Mecanicamente, esses robôs são fáceis de fazer. Eles só precisam de juntas básicas e têm dois atuadores que podem criar movimentos bastante fluidos. Essa estrutura é ideal para designers que estão interessados em fazer estruturas móveis. No entanto, eu não sendo um engenheiro mecânico, achei a cinemática muito difícil de traduzir para o código. Portanto, irei fornecer o código básico do Arduino que descobre a cinemática direta e inversa para que você possa usar isso facilmente em seus projetos futuros!;-)

Faça o download do código abaixo!

* EDITAR: para um projeto semelhante, dê uma olhada em https://haply.co *

Etapa 1: Construindo a Estrutura

Dependendo do propósito que você tem em mente, você deve primeiro projetar uma estrutura de 5 ligações. Pense nas medidas, atuadores que deseja usar e como conectar as articulações para movimentos suaves.

Para meu protótipo, eu executo meu código em um Arduino DUE que é controlado via serial por um programa em meu Mac que foi feito em Open Frameworks. O programa usa uma conexão UDP para se comunicar com um simulador de direção baseado em Unity 3D.

O protótipo Scribble usa rolamentos de 5 mm e é feito de acrílico cortado a laser de 5 mm. Os atuadores são motores hápticos de Frank van Valeknhoef que permitem a atuação, a leitura da posição e a emissão de uma força variável. Isso os tornou ideais para as propriedades hápticas desejadas do Scribble. Mais sobre seus atuadores podem ser encontrados aqui:

Etapa 2: Conheça os Valores de Seu Hardware

A cinemática direta é baseada na estação meteorológica Plot clock da SAP:

Conforme mostrado em sua configuração é estendido para o braço para segurar um marcador para desenhar. Isso foi removido, pois não servia para o protótipo do rabisco. Verifique o código deles se desejar adicionar este componente novamente. Os nomes na imagem são mantidos iguais na minha configuração.

Dependendo do seu hardware, o algoritmo precisa conhecer as propriedades do seu hardware:

int leftActuator, rightActuator; // ângulo para escrever para o atuador em graus, mude para flutuadores se desejar mais precisão

int posX, posY; // as coordenadas da localização do ponteiro

Defina a resolução dos seus valores de entrada

int posStepsX = 2000;

int posStepsY = 1000;

Dimensões de sua configuração, os valores estão em mm (ver imagem SAP)

# define L1 73 // comprimento do braço do motor, veja a imagem SAP (esquerda e direita são iguais)

# define L2 95 // braço de extensão de comprimento, consulte a imagem SAP (esquerda e direita são iguais)

#define rangeX 250 // intervalo máximo na direção X para o ponto se mover (da esquerda para a direita, 0 - maxVal)

#define rangeY 165 // intervalo máximo na direção Y para o ponto se mover (de 0 para maximizar o alcance enquanto permanece centrado)

# define originL 90 // distância de deslocamento do valor X mínimo para a posição central do atuador

#define originR 145 // distância de deslocamento do valor X mínimo para a posição central do atuador, a distância entre os dois motores é neste caso

Etapa 3: cinemática direta

Conforme mencionado na etapa anterior, a cinemática direta é baseada no algoritmo do SAP.

O vazio atualiza os valores de ângulo desejados do atuador esquerdo e direito definidos anteriormente. Com base nos valores X e Y inseridos, ele calculará os ângulos retos para colocar o ponteiro nesta posição.

void set_XY (double Tx, double Ty) // insira seus valores X e Y {// alguns vals que precisamos, mas não queremos salvar para long double dx, dy, c, a1, a2, Hx, Hy; // mapeia a resolução do inpit para o intervalo de sua configuração no mundo real int realX = map (Tx, 0, posStepsX, 0, rangeX); // troca se o mapeamento é invertido int realY = map (Ty, posStepsX, 0, 0, rangeY); // troca se o mapeamento é invertido // ângulo calculado para o atuador esquerdo // dx cartesiano / dy dx = realX - originL; // inclui offset dy = realY; // comprimento polar (c) e ângulo (a1) c = sqrt (dx * dx + dy * dy); a1 = atan2 (dy, dx); a2 = ângulo_de_retorno (L1, L2, c); leftActuator = floor (((M_PI - (a2 + a1)) * 4068) / 71); // ângulo final e converter de rad para deg // ângulo calc para o atuador direito dx = realX - originR; // inclui offset dy = realY; c = sqrt (dx * dx + dy * dy); a1 = atan2 (dy, dx); a2 = ângulo_de_retorno (L1, L2, c); Atuador direito = piso (((a1 - a2) * 4068) / 71); // ângulo final e converter de rad para deg}

Vazio adicional para cálculo de ângulo:

ângulo_de_retorno duplo (duplo a, duplo b, duplo c) {// regra do cosseno para o ângulo entre ce um retorno acos ((a * a + c * c - b * b) / (2 * a * c)); }

Etapa 4: Cinemática Inversa

A cinemática inversa funciona ao contrário. Você conecta a rotação de seus atuadores em graus e o vazio atualizará a posição definida anteriormente.

Observe que você precisará de atuadores ou de um sensor separado que possa ler o ângulo do braço. No meu caso, usei atuadores que podem ler e escrever suas posições simultaneamente. Sinta-se à vontade para experimentar isso e considere adicionar algum tipo de calibração para ter certeza de que seu ângulo foi lido corretamente.