Aprender

Como usar um sensor de flexão com um Arduino

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um sensor de flexão em A0ao vivo0.000 s 0.00x
Clique para abrir no editor
Um sensor de flexão de 5 V para A0 e um 47k de A0 para GND, num ATmega328P simulado. Arraste o controle para dobrar a fita.

Um sensor de flexão é uma fita cuja resistência aumenta quando dobra. Ligue um terminal em 5 V e o outro em A0, coloque um resistor de 47k de A0 para GND e leia com analogRead(). Reta, a leitura fica alta; dobrada, fica mais baixa. É o componente dentro de cada luva de mão robótica.

O circuito acima é um sensor de flexão de 2.2 polegadas com seu 47k num Uno. Aperte Rodar e arraste o controle para dobrar a fita. Reta, o monitor serial imprime "A0 = 668 (3264 mV)". Em ângulo reto ele lê "A0 = 439 (2145 mV)" e dobrada por completo "A0 = 327 (1598 mV)".

Abaixo está como a fita funciona, a ligação, duas maneiras de transformar a leitura em ângulo, um servo que copia seu dedo e como escolher o resistor.

O que você precisa

  • Um Arduino Uno
  • Um sensor de flexão, como a fita Spectra Symbol de 2.2 ou 4.5 polegadas
  • Um resistor de 47k (amarelo, violeta, laranja)
  • Um servo, para o dedo robótico
  • Uma protoboard e jumpers

Ligação

Componente e pinoVai paraNota
Sensor de flexão, qualquer terminal5 VNão tem polaridade, mas dobra num só sentido
Sensor de flexão, outro terminalA0
Resistor de 47kDe A0 para GNDFaz o divisor
Sinal do servoPino 9Para o dedo robótico; vermelho em 5 V, marrom em GND

Como funciona um sensor de flexão

Um lado da fita é impresso com tinta de carbono. Dobre-a com a tinta na parte de fora da curva e a tinta se rompe em ilhas menores, então a resistência sobe: cerca de 25k reta, 62.5k a 90 graus e 100k dobrada por completo, no simulador. Dobre no outro sentido e uma fita real quase não muda, então monte-a com o lado impresso para fora.

A fita é a metade de cima de um divisor, então mais resistência significa menos tensão em A0. É por isso que a leitura cai conforme você dobra.

Da leitura para graus com map()

O jeito rápido é medir a leitura reta e dobrada, e deixar map() esticar isso para 0 a 180. Reta, imprimiu "668 -> 0 graus" e dobrada "327 -> 180 graus". Até aqui tudo bem. Mas um ângulo reto imprimiu "439 -> 120 graus", não 90.

A resistência da fita sobe em linha reta com a dobra, mas um divisor não transforma resistência em tensão em linha reta, então o map() deforma o meio. Para uma luva que abre e fecha uma mão, isso não importa. Para um ângulo que você quer imprimir, use o próximo sketch.

Graus com map()
const int FLAT = 668;  // the reading with the strip flat
const int BENT = 327;  // and folded right over

void setup() {
  Serial.begin(9600);
}

void loop() {
  int reading = analogRead(A0);
  int angle = map(reading, FLAT, BENT, 0, 180);
  angle = constrain(angle, 0, 180);
  Serial.print(reading);
  Serial.print(" -> ");
  Serial.print(angle);
  Serial.println(" degrees");
  delay(500);
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Graus a partir da resistência

Calcule primeiro a resistência da fita a partir do divisor, R = 47000 * (1023 - raw) / raw, depois transforme a resistência em graus. Reta, imprimiu "24977 ohms -> 0 graus", em ângulo reto "62523 ohms -> 90 graus" e dobrada "100036 ohms -> 180 graus". A 45 graus imprimiu 44, que é o mais perto que os passos do ADC permitem.

Numa fita real, meça FLAT_OHMS e BENT_OHMS com a sua própria fita, já que cada uma é um pouco diferente.

Graus a partir dos ohms
const long R_FIXED = 47000;    // the resistor from A0 to GND
const long FLAT_OHMS = 25000;  // the strip flat
const long BENT_OHMS = 100000; // the strip folded over

void setup() {
  Serial.begin(9600);
}

void loop() {
  int raw = analogRead(A0);
  long ohms = R_FIXED * (1023 - raw) / raw;
  long angle = (ohms - FLAT_OHMS) * 180 / (BENT_OHMS - FLAT_OHMS);
  angle = constrain(angle, 0, 180);
  Serial.print(ohms);
  Serial.print(" ohms -> ");
  Serial.print(angle);
  Serial.println(" degrees");
  delay(500);
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Um dedo de servo que copia o seu

Adicione um servo no pino 9 e a fita pode comandá-lo. Este é um dedo de uma mão robótica: fixe a fita ao longo do seu dedo com fita adesiva e o servo acompanha conforme você o dobra. Reta, o servo ficou em 0 graus, e dobrada foi a 180.

Ele usa a versão com map(), então uma fita dobrada a 90 graus pôs o servo em 120. Para uma mão tudo bem; o dedo ainda fecha quando o seu fecha. Cinco fitas em A0 a A4 e cinco servos fazem a mão inteira; o projeto da mão robótica faz exatamente isso num Mega.

Um dedo com servo
#include <Servo.h>

Servo finger;

void setup() {
  finger.attach(9);
}

void loop() {
  int reading = analogRead(A0);
  int angle = map(reading, 668, 327, 0, 180);
  finger.write(constrain(angle, 0, 180));
  delay(20);
}

Abrir este sketch no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Escolhendo o resistor

O melhor resistor fica perto da resistência própria da fita ao longo de sua faixa. Com um resistor de 47k, a leitura foi de 668 esticada para 327 dobrada, uma variação de 341 unidades. Um resistor de 10k variou apenas de 292 a 93, e um de 100k de 818 a 512. Mais variação significa um ângulo mais suave.

O que a simulação deixa de fora

Toda fita aqui é a típica: 25k esticada e 100k dobrada, com a resistência acompanhando o cursor de imediato. Uma fita real pode variar 30 por cento para mais ou para menos dos 25k esticada, e por isso você mede a sua. Ela também lê diferente dependendo de onde ao longo do comprimento está a dobra e de quão apertada ela é, não só do ângulo, então uma junta de dedo e uma curva suave no mesmo ângulo dão números diferentes.

Uma fita real volta lentamente depois que você a endireita, então a leitura demora um momento para estabilizar, e ela lê um pouco mais alto conforme se desgasta. Calibre na mão ou na dobradiça onde ela vai ficar, e verifique de novo depois de algumas semanas de uso.

Erros comuns

Dobrar no lado errado. Monte a fita com o lado impresso para fora da dobra, ou uma fita real quase não muda.

Dobrar nos terminais. A junta onde os fios encontram a fita é o ponto fraco; cole ou prenda essa ponta com fita para que ela nunca dobre.

Usar um resistor de 10k porque o guia de FSR usava. Isso varia apenas cerca de 200 unidades com esta fita; use 47k.

Deixar de fora o constrain(). Uma fita dobrada um pouco além do que você mediu dá ao map() um número fora da faixa, e o servo recebe mais de 180 graus.

Copiar FLAT e BENT de outra pessoa. Meça sua própria fita esticada e dobrada, e use esses números.

Abra este circuito no editor. Arduino Uno: um sensor de flexão no A0, ligado como aparece no topo desta página. Mude um componente ou um valor e rode de novo.

Perguntas

Como conectar um sensor de flexão a um Arduino?

Um terminal no 5 V, o outro no A0, e um resistor de 47k do A0 ao GND. Leia com analogRead(A0): mais alto esticada, mais baixo conforme dobra.

Qual resistor usar com um sensor de flexão?

Algo perto da faixa própria da fita, 47k para uma fita de 2,2 polegadas que vai de 25k a 100k. Aqui ela deu uma variação de 341 unidades, contra 199 com um de 10k.

Como transformar a leitura de um sensor de flexão em um ângulo?

Meça a leitura esticada e dobrada e use map() e constrain(). Para um ângulo real, calcule primeiro a resistência a partir do divisor, depois converta isso para graus.

Um sensor de flexão funciona dobrando para os dois lados?

Não. Ele é feito para dobrar para um lado, com o lado impresso para fora. Dobrado para o outro lado, uma fita real muda muito pouco.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.