Introduction:

Recently, I wanted to measure the weight of my bike. I found not very convenient to take a body weight scale, measure me with and without the bike and make the difference.
Also, when I travel with big luggage (again with a bike bag per example), it is much more complicated to ensure I'm not over the limit.
So, I decided to build some small scales, here limited to 10kg (depend of the strain gauge sensor), and each of them (up to 4) will send in real time the measurement to a receiver which is displaying the data received by each scales and make the addition.
The usage is quite simple. Put one scale under one part of the object to measure, then read the result on the receiver. For the bike, I put one scale under each wheel and I see the total. For the long bike bag, I can put 4 scales under each corner of the bag to see the total weight. 

Hardware:

For each element, scale or receiver, I used an ESP32 module with OLED display embedded (HW-724).
The display is a simple 128*64 and standard driver.
Each scale is using well known HX711 I2C 24b A/D, connected to a weight sensor, which is 4 strain gauges connected like Wheatstone bridge. This weight sensor is defined for a max weight and I choose 10kg.
The HX711 is on a small PCB which is stick on the back of the ESP32. 

As the ESP32 module does not have battery connectivity, I added, in a simple way, a small powerbank module I developed previously here. I just used the charging and 5V output capability. So, each scale has their own battery and can be recharged.
I could have chosen a module like TTGO which has display and battery powered possibility but I didn't have it at home (and more expensive).
A press button is added on the module.

For the receiver, same module, HW-724 and nothing else. It is powered at this moment by a standard powerbank.

The transmission between the scales and the receiver uses the ESP-NOW standard, quite easy to manage. Just need to know the MAC address of the receiver and send the data.

Software on scales side:

Each scale must have an unique ID, which is in the code (SCALE_ID). So, each code must be compile with this dedicated ID to the each scale.

At start, the software will measure to setup the 0 (tare function). Nothing must be on the scale for that.
After display 0, anything can be measure. If press the button, it is a tare function, put the scale to 0 despite what is on it. A simple timer 100ms will launch the measurement and send it through ESP-NOW only if there is a change.

If the button is press at power on, it is the full calibration of the scale. A weight of 200 grs must be prepared and put on the scale when it is written on the display. The scale function will output a coefficient which will be always use after that. It will be stored in the flash of the ESP32.

On the display, during the measurement, the ID number of the scale is indicated.

The software could be improved and been unique (no need to compile with the different ID) if all the MAC address of each modules are declared in the program and affected to one ID. It could read it at switch on, compare to each MAC address and setup the right ID. Not yet done.

In the program, a simple function at the beginning is used to read the MAC address. A compilation switch need to be setup to compile and execute one time to note and write the MAC address.

Software on receiver:

The receiver is just listening to the ESP-NOW protocol and each time it received data, it extract the ID scale, weight data and display on the screen. One line for each scale. If a scale is not present or stop to send data, it is removed the previous measurement.
Finally, it displayed the sum of the scales measurement.

Mockup:

I found some round of plexiglass, add the sensor, ESP32 module, powerbank PCBA and a lithium battery.
To avoid conflict on the 5v of the ESP32 module, the powerbank PCBA send the 5v through an micro USB cable.

Conclusion:

Funny small project, interesting to work with Strain gauge, some other ideas are coming too. And now, I can optimize my bike weight...