Week 09 - Input devices

Group Assignment:

• Probe an input device(s)'s analog levels and digital signals
• Document your work to the group work page and reflect on your individual page what you learned

Please refer to the group page to read about our group assignment.

Individual Assignment:

• Measure something: add a sensor to a microcontroller board that you have designed and read it.

Learnings from this week's group assignment

Intro

This week is going to be very busy, because there are so many different input devices I would like to try.

Among the once I choose are both analog and digital devices.

• Strain gauges and load-cell (both purchased and home-made)
• Gyro/Accelerometer
• Hall effect sensor

As a starting point I discussed with my instructor and he suggested different breakout boards and microcontrollers. I'm going to make one microcontroller development board for input devices, using the XIAO SAMD21.

I looked at the different interfaces and started making a drawing in KiCAD with headers to connect the breakout-boards.

• For the strain gauges and load-cells I'm going to use the HX-711 ADC which connects to a digital serial interface using one data pin and one clock pin (not I2C).
• The Gyro/Accelerometer is the GY-521 breakout board with the MPU6050 chip, communicating via I2C.
• The hall effect sensor is from the inventory will be connected directly to the analog input of the MCU. I'm going to design a breakout board for it.

Here is the development board I made and the small breakout board for the hall effect sensor by it's side.

I have four headers to connect four HX711 ciruits, one for I2C and one for analog signal.

Force measurement

Strain gauges are very fascinating. For this week (and possibly the final project) I ordered these ready-to use strain gauges.

I also ordered three load cells.

For testing I designed a test bench in Fusion and printed it.

The idea is to test both load cells and strain gauges in either a three or four-arm setup. The arms itself have to be milled from aluminium or PCB stock.

My instructor recommended the HX711 ADC circuit. Here is an example code I adopted for the different scenarios I tried:

#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 2;
const int LOADCELL_SCK_PIN = 3;

HX711 scale;

void setup() {
  Serial.begin(57600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
}

void loop() {

  if (scale.is_ready()) {
    long reading = scale.read();
    Serial.print("HX711 reading: ");
    Serial.println(reading);
  } else {
    Serial.println("HX711 not found.");
  }

  delay(1000);

}

Homemade 2-axis force sensor

I wanted to try and make a very simple strain gauge sensor and see if it would be possible to make a compact but yet functional sensor with the standard PCB stock and Roland MDX-20.

The initial design has four arms and on each arm a trace that measures roughly 300 mm. The resistance of each loop should be around 0,5 Ω. Two opposite arms are connected as a half-bridge.

Here is the schematic:

From the Fusion plate I made the Edge.Cut layer and tried to fit the traces. I decided to use 360 Ω resistors, because the strain gauges I ordered have a rated resistance of 350 Ω, but 350 Ω wasn't available as SMD resistor.

The size of the arm was selected, that it would just fit on the PCB FR1 stock of 4'' x 6''.

Here are the traces and outlines of the strain gauge arm.

The milling went well, accept for the first edge cutting process that failed, because the allen key was quite worn and I couldn't fasten the grub screw holding the bit well enough.

After soldering the resistors and some wires to the PCB it was time to try and connect the sensor. However, I discovered a short circuit between the excitation wires and had to unsolder the resistors and check the traces underneath. After fixing that and reassembling everything - here is the view from below.

When testing the sensor there where a view issues with my development board or the HX711, that I wasn't aware of.

Operating voltage

The XFW HX711 breakout board is said to have an operating voltage of 5 V DC (2,6 V ~ 5,5 V) and I supplied all headers for these board with 3,3 V, but they wouldn't work until I changed to 5 V.

Clock pins

I assumed, that similar to I2C one and the same clock output could be used for multiple sensor. That isn't true - each board needs it's own clock!

Because of the two issues mentioned above I had to make quite some modifications to the development board to make it work. That resulted in some chaos with jumper wires and less reliable connections, but here is the first test in the test bench with reading one half bridge (one axis).

After connecting the second axis and adding a one-minute running average filter to the signal I was quite happy with the response and result.

Then I continued playing around with the "joystick" trying to figure out, why the response of the two axis seemed to be not the same, when moving in different directions and unfortunately one arm on the PCB snapped, so that was the sign to stop there and continue with the other sensors.

Load cell

As mentioned above, I have three load cells to test and to make a two-dimensional force sensor, I decided to make a flex plate with three arms out of aluminium. It has the same dimensions as the PCB strain gauge and fits onto the same test bench.

The only sheet material available is AlMg3, which is not the best material for milling. I'm using the shopbot and started setting up a coated plywood piece. Onto that I applied masking tape, as well as on one side of the aluminium sheet. Then I applied glue to the masking tape and pressed everything together.

This will hold the sheet down firmly and allows me to mill without further clamps. Because I only glued down one end of the larger piece, I added a wood clamp nevertheless, to stop the loose end from vibrating.

Because of the small holes, I used a 1/8'' end mill with two flutes. However the standard settings out of V-carve were a bit fast or the bit was dull - it made a rough cut and eventually broke. I changed to another bit and went slower this time. The result looks much better (three arm plate in the background).

Aluminium settings with 1/8'' end mill

I used a speed of 750 mm/min and a cutting depth of 0,25 mm.

Here are the two plates after deburring. It would be very nice to have access to a water-jet cutter for this project...

Note

The four-arm plate I made because, it meant little additional work, with thesheet and mill already set up and eventually I could use it for testing the strain gauges. However, as expected, I found the 2 mm sheet quite rigid and might repeat it in 1 mm aluminium to add more flexibility.

Because of the above mentioned issues with the development board, I made another iteration of it, to improve the wiring and overall reliability. Now, all pins of the SAMD21 are in use.

Here is the code I used to read and plot the three load cell values.

#include "HX711.h"

// HX711 circuit wiring
const int D0_DOUT_PIN = D6;
const int D0_SCK_PIN = D3;

const int D1_DOUT_PIN = D10;
const int D1_SCK_PIN = D9;

const int D2_DOUT_PIN = D1;
const int D2_SCK_PIN = D2;

HX711 D0_scale;
HX711 D1_scale;
HX711 D2_scale;

void setup() {
  Serial.begin(57600);
  D0_scale.begin(D0_DOUT_PIN, D0_SCK_PIN);
  D1_scale.begin(D1_DOUT_PIN, D1_SCK_PIN);
  D2_scale.begin(D2_DOUT_PIN, D2_SCK_PIN);
  delay(1000);

  if(D0_scale.is_ready()){
    D0_scale.tare();
    Serial.println("S0 tare");
  }
  if(D1_scale.is_ready()){
    D1_scale.tare();
    Serial.println("S1 tare");
  }
  if(D2_scale.is_ready()){
    D2_scale.tare();
    Serial.println("S2 tare");
  }  
}

void loop() {
  if (D0_scale.is_ready()) {
    long red0D = D0_scale.read();
    long F0D = 0.9*F0D+0.1*red0D;
    Serial.print(">Scale0:");
    Serial.println(F0D);
  } else {
    Serial.println("Scale 0 not found.");
  }

  if (D1_scale.is_ready()) {
    long red1D = D1_scale.read();
    long F1D = 0.9*F1D+0.1*red1D;
    Serial.print(">Scale1:");
    Serial.println(F1D);
  } else {
    Serial.print("Scale 1 not found.");
  }

  if (D2_scale.is_ready()) {
    long red2D = D2_scale.read();
    long F2D = 0.9*F2D+0.1*red2D;
    Serial.print(">Scale2:");
    Serial.println(F2D);
  } else {
    Serial.println("Scale 2 not found.");
  }

  delay(100);

}

And the video shows the response of the load cells to pressure and movement of the lever arm.

Strain gauges

The third approach to measure force will be to use purchased strain gauges and apply them to a flexing aluminium plate.

First I milled the same outlines as for the four-arm PCB, but from 1 mm aluminium sheet (AlMg3).

Then I prepared for attaching the strain gauges. They have to be handeled very carefully and glued into exactly the right spot with a good, thin contact glue.

I used clear tape to position the strain gauges and make sure everything is aligned. Then I pulled them back with the tape, degreased the aluminium and applied a thin layer of glue, before pressing them down and using clamps to apply constant pressure.

Next day I removed the tape an cleaned the surface.

Now it was time to make a PCB to connect the wires permanently and without movement.

I'm using two eight-pin headers to connect all eight strain gauges. This allows me later to test different configurations of Wheatstone-Bridges with different shields.

Here I have connected the strain gauges to the PCB. Because of the good heat conductivity, soldering the small pads on the strain gauges is a bit difficult, as the heat dissipates quickly into the aluminium below.

On the next picture, the headers are soldered onto the PCB and the wires are protected and hold in place by casting them in epoxy.

The strain plate is ready, but for testing it, I need a shield with different circuits for measuring a half-bridge or full-bridge setup.

On each arm there is one stressed and one unstressed strain gauge. I would like to either measure each arm seperately as a hal bridge setup or measure two opposing arms together in a full-bridge configuration.

Here is the schematic I came up with. I will need to use jumpers to connect the excitation voltage to the right resistors. Also 350 Ω resistors are not a standard size, so I had to connect a 330 Ω and a 20 Ω resistor together in row.

It is a bit hard to visualize this properly, but the four-pin header is to feed 5 V to the SMD resistors for half-bridge measurement.

The strain gauges are connected to A1+/A1 and so on.

The measuring points can be identified by "M". So measuring voltage between MA1 and MA2 gives the half-bridge measurement of the first arm.

Measuring voltage bewtween MA1 and MC1 is for the full-bdrige configuration of the two opposing arms.

Here the shield is milled, soldered and with epoxy-casted wires, waiting to cure.

With everyhting assembled and the shield connected to the arm, I tested the strain gauges, with the same program as for the load cells.

First I noticed, how sensitive the strain gauges are. A tiny movement of the arm or tapping on the area, where the strain gauges are creates a clear spike on the plot.

The video shows the response of the full-bridge with arm A and C.

As you can see, the signal is creeping very slowly until it reaches the final value. That takes about 30 s. The same behaviour can be observed in the opposite direction.

Maybe the epoxy is the reason?

At this point I figured out, that there must be some failure/error on my shield. I had double-checked all resistances on the arm, but the full-bridge B/D didn't give a meaningful result.

Also I have to reconsidered how I connect the opposing strain gauges in the bridge. I need to invert the signal from the opposite side, so that I get a negative value for pressure from one and a positive from the other side.

I might not have enough time to finish all that in this week.

Gyroscope / Accelerometer

The GY-521 breakout board uses the MPU-6050 which has six degrees of freedom.

It returns acceleration and magnetic field in three axes.

The connection is easy via I2C.

Here is the example code I used slightly modified from the arduino forum to print the orientation in X Y and Z.

#include<Wire.h>
const int MPU=0x68; 
int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;

void  setup(){
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B);  
  Wire.write(0);    
  Wire.endTransmission(true);
  Serial.begin(57600);
}
void  loop(){
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);  
  Wire.endTransmission(false);
  Wire.requestFrom(MPU,12,true);  
  AcX=Wire.read()<<8|Wire.read();    
  AcY=Wire.read()<<8|Wire.read();  
  AcZ=Wire.read()<<8|Wire.read();  
  GyX=Wire.read()<<8|Wire.read();  
  GyY=Wire.read()<<8|Wire.read();  
  GyZ=Wire.read()<<8|Wire.read();  

  Serial.print(">AX:"); Serial.println(AcX); 
  Serial.print(">AY:"); Serial.println(AcY); 
  Serial.print(">AZ:");  Serial.println(AcZ);
//  Serial.print(">GX:"); Serial.println(GyX); 
//  Serial.print(">GY:"); Serial.println(GyY); 
//  Serial.print(">GZ:"); Serial.println(GyZ);
  delay(100);
}

The video shows the response to orientation of the sensor.

Hall effect sensor

The hall effect sensor is a very simple A1324LLHLT-T with three pins, using 5 V input voltage and responding with a analog voltage. If found this page, that describes the sensor.

I also looked at the datasheet, where it is recommended using a 0,1 µF bypass filter between VCC and GND.

I made this small breakout board:

And here is the code I used:

const int SensorPin = A0;

void setup() {
  Serial.begin(57600);       // Open serial communication
  pinMode(SensorPin, INPUT); //Set input pin
}

void loop() {
  int hall = analogRead(SensorPin);
  Serial.print(">Hall:");
  Serial.println(hall);      // Print sensor reading
  delay(100);
}

The serial plotter shows a clear response when moving a magnet close to the sensor.