Here I present a "Touch Sensor" for InMoov's finger tip

Its uses a Full Bridge Strain Gauge circuit, this consists of 4 resistive strain elements and an instrumentation operational amplifier.

Basic Full Bridge :-

[1] Two active elements (one placed on top surface , other placed on bottom surface)

When one Flexes the other extends (when one goes + the other goes -), effectively giving you double the amount of signal (neat)

[2] Two Ref elements ( these are mounted at right angles to the active elements and are used for temperature compensation - these are 100% required, do not skimp and use resistors , trust me on this one).

The resulting set up gives a very small voltage differential (circa +/- 20mv) , however it is a very sensitive arrangement.

Below :- You can see one sensor has been superglued to a 1.3mm 3d Printed ABS flex plate that extends into the lower part of the finger base.... also just hidden below the yellow knot is the temperature reference sensor.

Beneath the flex sensor is the same arrangement for the second half of the bridge.

To pick up this small voltage a HX711 Operational amplifier is used, it is a precision 24-bit analog- to-digital converter (ADC) designed for weigh scales and industrial control applications that interface directly with bridge sensors.

Below is the HX711 amplifier , you might note that it has been hacked by lifting Pin 15 and tie_ing it to the VCC line, this speeds up the amplifier from factory default 10Hz to overclocked 80Hz (winwin).

Connection to the amplifier is relatively easy :-

[1] E+ is the constant  + reference Voltage.

[2] E- is the constant  - reference Voltage.

[3] A- is the negative going signal leg.

[4] A+ is the positive going signal leg.

 

The HX711 is accesed via a serial interface, luckily there are Arduio Libraries available to decode and set up the chip.

As you can see below an OLED has been added to display the output. (which also goes negative)

#include "HX711.h"
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define OLED_RESET 16
Adafruit_SSD1306 display(OLED_RESET);

#define LOGO16_GLCD_HEIGHT 16
#define LOGO16_GLCD_WIDTH  16
static const unsigned char PROGMEM logo16_glcd_bmp[] =
{ B00000000, B11000000,  B00000001, B11000000,  B00000001, B11000000,  B00000011, B11100000,  B11110011, B11100000,  B11111110, B11111000,  B01111110, B11111111,  B00110011, B10011111,
  B00011111, B11111100,  B00001101, B01110000,  B00011011, B10100000,  B00111111, B11100000,  B00111111, B11110000,  B01111100, B11110000,  B01110000, B01110000,  B00000000, B00110000 };

HX711 scale(4,5);        // parameter "gain" is ommited; the default value 128 is used by the library

void setup() {
 display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // initialize with the I2C addr 0x3C (for the 128x32)
 display.setTextSize(2);
  display.setTextColor(WHITE);
  display.clearDisplay();
  display.setCursor(0,0);
  display.println("InMoov");
  display.println("TouchSense");
  display.display();
  delay(1000);
  display.setTextSize(3);
  Serial.begin(38400);
  Serial.println(scale.read());            // print a raw reading from the ADC
  Serial.print("read average: \t\t");
  Serial.println(scale.read_average(20));      // print the average of 20 readings from the ADC
  Serial.print("get value: \t\t");
  Serial.println(scale.get_value(5));        // print the average of 5 readings from the ADC minus the tare weight (not set yet)
  Serial.print("get units: \t\t");
  Serial.println(scale.get_units(5), 1);    // print the average of 5 readings from the ADC minus tare weight (not set) divided

  scale.set_scale(100.f);                      // this value is obtained by calibrating the scale with known weights; see the README for details
  scale.tare();                        // reset the scale to 0
}

void loop() {
display.clearDisplay();
 display.setCursor(0,0);
 display.println(scale.get_units(5), 1);
  Serial.print("\t| average:\t");
   display.display();
 Serial.println(scale.get_units(5), 1);        // print the average of 5 readings from the ADC minus tare weight, divided
  delay(100);
   }

 

Bretzel_59

6 years 5 months ago

Wonderful Gareth !

I bought some strain gauge and electronic but it’s quarter bridge only. I didn’t know this board wich is really affordable. So I’m buying some for testing. Because I want some torque control on my bldc servo. This is greaaaaaaat!!!!!

hairygael

6 years 4 months ago

You really are impressive!!

I still remember the smelling sensor for InMoov you made!!

I really enjoy seing what you create!

Now, I have designed recently a new finger tip with a Hal sensor and very small magnet based on an idea of Marten, and it works very nicely.

But I came to the conclusion that, what is a real trouble is not so much the sensor itself, but all the wires that need to run at the end of the finger remaining flexible after thousands of uses.

The new finger design needs three wires when my initial sensor needed only two. Well, finding a cleaver way to run those three cables took me a hell of a work to design something proper within the fingers.

I see you have four wires for your sensor... OH NO!

:)

Yo° Gael,

I have been checking a variety of touch sensors for quite a while now,

I have found this way by far is the most repeatable, its like having the responce of a kitchen weighing scale on your fingertip.

The system uses 3 wires from the MCU, into the amplifier chip and then 4 wires into the strain guages in the tip its self.

My idea would be to place the amplifier chip (its a small chip)  into the finger tip its self, (there is enough room anyway its better to keep sensors and amplifier close together), meaning you have to only worry about 2 supply wires and 1 serial data wire. (no worry about flimsy sensor wire as these will be contained in the tip itself).

It looks simple, however it is a pig of a job to solder and place the componants just in the right places. extending it to 10 fingers  would be a job and a half.

regards Gareth