Week 9

Input devices

Week assignment

1. Group assignment:
   • probe an input device’s analog levels and digital signals. ✔
2. Individual assignment:
   • measure something: add a sensor to a microcontroller board that you have designed and read it. ✔

Group assignment

For our group assignment, we each decided to check the digital and analog readings of the input devices we’re considering for our final project. I focused on testing a beam-type load cell and a platform-type load cell. The analog signal before the HX711 converter is very small and changes when we place a load on the load cell.

Link to week 9 group assignment

Individual assignment

Load Cell HX711

As part of my week 4 Embedded Design assignment, I adapted some code to read values from a beam-type load cell connected to an Arduino UNO. I manually calibrated the load cell by scaling the readings until I got an accurate measurement of the applied load.

This week, I want to take it a step further! Instead of reading just one platform load cell, I’ll use the PCB I made last week to read data from, at least, two of them. For my final project, I’ll need to work with nine of these sensors to determine the bending moments of a beam supported at both ends, with cantilevers on each side. The idea is to measure the loads applied by people sitting in the nine seats I’m designing.

This week, I had the opportunity to use a new oscilloscope. We purchased it during Christmas, but due to various reasons, its arrival was delayed until now. Since I had already worked with the previous model, understanding its operation was straightforward. It allowed me to visualize the signals generated by one of the beam-type load cells I had previously used.

Each platform load cell consists of four strain gauge elements arranged in a Wheatstone bridge configuration. This setup allows us to detect even the smallest changes in resistance. Since these resistance changes are extremely tiny, I’ll need to use an HX711 amplifier, a high-resolution (24-bit) ADC.

I’ve wired up four load cells so that their signals add themselves together, giving me a final reading of the total load applied across all four sensors. Here’s a wiring diagram for reference:

Once I had the wiring figured out, I moved on to soldering everything together:

I reused the program I had prepared in Week 4 for the Beam-type load cell and adapted it for platform-type load cells connected to an HX711.

#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = D0;
const int LOADCELL_SCK_PIN = D3;

HX711 load;

void setup() 
{
  Serial.begin(115200);
  load.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  delay(250);
  
  load.tare(20);  // Take 20 readings, the average is the tare weight
  //load.set_scale(397); // The default scale is 1
  load.set_scale(28);
  //load.tare(-400);
}

void loop() {

  if (load.is_ready()) 
  {
    //long reading = load.read();               // Raw reading, no tare or scaling
    //long reading = load.get_value();          // Reading minus tare, done 10 times
    long reading = load.get_units(10);        // Weight without tare and adjusted
    
     Serial.println(reading);
   } 
  else 
    Serial.println("HX711 not found.");
  
  delay(500);
  
}

The next step is to connect the second set of load cells. To do this, I had to review the pinout of the Xiao ESP32C3 MCU.

I checked out the info on the XIAO ESP32C3 from wiki.seedstudio.com.

For each HX711, I need to connect the following pins:

• GND
• DT (Data)
• SCK (Clock)
• Vcc

With the first amplifier, I used D0 and D3. My approach is to share a single CLK signal for all the load cells connected to the MCU. To test the setup, I used a breadboard to connect the two CLK signals of the HX711 modules to a single pin on the XIAO, specifically D3.

Therefore, I will use a separate pin for the Data signal of the second HX711.

#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL1_DOUT_PIN = D4;
const int LOADCELL2_DOUT_PIN = D0;
const int LOADCELL_SCK_PIN = D3;

HX711 load;
HX711 load2;

void setup() {
  Serial.begin(115200);
  load.begin(LOADCELL1_DOUT_PIN, LOADCELL_SCK_PIN);
  load2.begin(LOADCELL2_DOUT_PIN, LOADCELL_SCK_PIN);
  
  Serial.println("Inicio tara");
  load.tare(20);   // Hacer 20 lecturas, el promedio es la tara
  Serial.println("Hola tara1");
  load2.tare(20);  // Hacer 20 lecturas, el promedio es la tara
  Serial.println("Hola tara2");
  //load.set_scale(397); //La escala por defecto es 1
  //load.set_scale(893);
  //load.tare(-18260);  // Hacer 20 lecturas, el promedio es la tara
}

void loop() {

  if (load.is_ready()) {
    long reading = load.read();  // Lectura sin tarar ni escalar
    //long reading = load.get_value( );          // Valor leido menos tara, hacer 10 veces)
    //long reading = load.get_units(10);         // Peso sin tara y corregido

    Serial.print("Cell1:");
    Serial.print(reading);
  } else {
    Serial.println("Cell 1 HX711 not found.");
  }
   if (load2.is_ready()) {
    long reading = load2.read();  // Lectura sin tarar ni escalar
    //long reading = load.get_value( );          // Valor leido menos tara, hacer 10 veces)
    //long reading = load.get_units(10);              // Peso sin tara y corregido
    Serial.print(" Cell2:");
    Serial.println(reading);
  } else {
    Serial.println("Cell 2 HX711 not found.");
  }
  delay(500);
}

However, with this code, the reading from the second load cell did not work.

After reviewing the code, I looked for information on multiple connections using a shared SCK.
I examined the available code from HX711-multi.

It is an old implementation that did not work for me, but it gave me the idea to incorporate a series of delays to allow the MCU enough time to assign a unique CLK to each load cell. The code, which is still quite basic, is as follows:

#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL1_DOUT_PIN = D4;
const int LOADCELL2_DOUT_PIN = D0;
const int LOADCELL_SCK_PIN = D3;

HX711 load;
HX711 load2;

void setup() {
  Serial.begin(115200);
  load.begin(LOADCELL1_DOUT_PIN, LOADCELL_SCK_PIN);
  delay(500);
  load2.begin(LOADCELL2_DOUT_PIN, LOADCELL_SCK_PIN);
  delay(500);

  Serial.println("Inicio tara");
  load.tare(20);   // Hacer 20 lecturas, el promedio es la tara
  Serial.println("Hola tara1");
  delay(100);
  load2.tare(20);  // Hacer 20 lecturas, el promedio es la tara
  Serial.println("Hola tara2");
  //load.set_scale(397); //La escala por defecto es 1
  //load.set_scale(893);
  //load.tare(-18260);  // Hacer 20 lecturas, el promedio es la tara
}

void loop() {

  if (load.is_ready()) {
    long reading = load.read();  // Lectura sin tarar ni escalar
    //long reading = load.get_value( );          // Valor leido menos tara, hacer 10 veces)
    //long reading = load.get_units(10);         // Peso sin tara y corregido

    Serial.print("Cell1:");
    Serial.print(reading);
  } else {
    Serial.println("Cell 1 HX711 not found.");
  }

   delay(500);

  if (load2.is_ready()) {
    long reading = load2.read();  // Lectura sin tarar ni escalar
    //long reading = load.get_value( );          // Valor leido menos tara, hacer 10 veces)
    //long reading = load.get_units(10);              // Peso sin tara y corregido
    Serial.print(" Cell2:");
    Serial.println(reading);
  } else {
    Serial.println("Cell 2 HX711 not found.");
  }
  delay(500);
}

Debugging Load Cell Readings with Fab Academy ChatGPT

With the delay, the cell readings worked correctly. The only issue was the calibration of the load cells. To update the code I had prepared, I accessed the Fab Academy ChatGPT and asked the following questions sequentially:

1. Could you adjust this code to increase the number of load cells from 2 to 9?
   Here is the adjusted code to support up to nine load cells using the HX711 sensor. Arrays have been added to efficiently manage multiple sensors and reduce code repetition.

2. Could you provide a code to automate the system’s taring process? Here is an improved version of the code that automates the taring process of the nine load cells at system startup and allows recalibration at any time by sending a command from the serial monitor.

3. I am using the same CLK for all the scales. Could you add a delay so they are read sequentially? Sure! Here is the adjusted code so that the load cells are read sequentially with a small delay() between each reading. This helps prevent potential interference since they all share the same CLK.

4. It now reads the loads, but the auto-calibration is not working. It seems that the tare() method is not functioning as expected for auto-calibration. Here is an improved version of the code that not only tares each load cell but also performs an initial auto-calibration, storing reference values to adjust the readings.

5. If I wanted to display the data in the Serial Plotter instead of just the Serial Monitor, how would this code be applied to only two load cells?
   To visualize the data in the Arduino Serial Plotter, you need to print the values in an appropriate format, without additional text, using tabulations (\t) or commas to separate the data from the load cells.

6. One of the cells is now returning a value of 0. Check the delays to ensure the code works with both, remembering that the CLK is shared.
   If one of the load cells is returning 0, the code may not be allowing enough time for the HX711 sensors to respond correctly. Since all the cells share the same CLK, it is crucial to prevent them from interfering with each other during readings.

7. Some data is still being lost due to the delay. Maybe it’s not enough.
   If data is still being lost, we need to increase the delays and ensure that each cell is fully read before moving on to the next one.

I ran different tests with each version of the code and tweaked it manually until it worked just the way I wanted for the readings.

Lastly, I had to confirm the calibration’s accuracy by comparing an object’s weight on a digital scale with the load cell readings, the result was correct.

Comparing readings

During the Iberian group review on Tuesday, April 1st, Pablo mentioned that it would be a good idea to include a table comparing the direct reading of the load cell with different known weights. The idea is to weigh objects with significantly different weights to see how the values change with various applied loads.

After the review, I spent some time updating the sections of my final project. Then, during the global review on Wednesday, April 2nd, I suddenly remembered this, and I think it’s definitely worth noting down!

Final Thoughts

At first, I thought measuring the analog and digital signals from the load cells would be more stable. However, I’ve realized that since these are very small values and not amplified, the readings fluctuate within a specific range.

When force is applied to a load cell, it responds by changing the value displayed on the oscilloscope. In the case of a digital signal reading at the output of the HX711 ADC amplifier, I’ve noticed that it appears as a sequence of discrete values on the oscilloscope screen. At that point, it’s possible to adjust the visualization, measurement and analysis scales accordingly.

For my final project, I’ll need to connect up to nine HX711 modules because I’ll have to write a code that enables automatic calibration of the load cells positioned under each seat. The system will also need a feature that allows for taring at a specific moment.

Files week 9

Tare auto - Manual calibration
Reading two Loadcells autocalibrated zip