Blog - Sketching with Hardware

Team 6 – The Naughty Weighn

Published on: | Author: Julia Vehns | Categories: 2018b, Projects

The Idea

There are many approaches and suggestions to lose or not to pick up more weight. Let me guess, none of these approaches have helped you? We would like to introduce you to a completely different method: The Naughty Weighn 😈

The Naughty Weighn is a smart scale that recognizes when you’ve gained or lost weight. And well… it will let you know…but in a naughty way and everyone around you will see it. Have a look at our video to get a first impression:

You can see a detailed setup of the scale in Image 1:

Image 1: Setup of the Naughty Weighn

How the scale works: When the person on the scale has lost weight, it switches to “party mode” and celebrates the user with a colorful LED display underneath the scale. If, on the other hand, the user has gained weight, it is indicated to him in a wicked way. The LED’s under the scale suddenly turn dark red and the mirror changes its shape so that you look thicker and thicker in it.

Isn’t that mean? Welcome to the topic of this year’s Sketching with hardware, home gadgets with a certain twist (Image 2):

Image 2: Topic of Sketching with Hardware 2018b – Home Naught-o-mation

You want to know more about the system’s functionality or you want to rebuild the Naughty Weighn? Then this is the right place for you:

What you Need for Building the Naughty Weighn

  • 1x Arduino Mega – We used an Arduino Mega, but other Arduino versions should work also
  • 1x breadboard big
  • 1x breadboard small (for the 3-digit display)
  • jumper cables/ Wires for connecting the parts with the Arduino

For the Scale

  • 1x scale with 4x 50 kg load cells – We bought a scale of the company “Soehnle” called “Bamboo” which included those load cells
  • 1x analog-to-digital converter (ADC) HX711 – It is used for amplifying the signals from the four load cells and reporting them to the Arduino
  • 1x 3-digit LED display
  • 1x stable wooden case underneath the scale – It is used to hide the Arduino and wires (we used one wooden board and 3 wood billets)
  • 1x LED strip with 15 LEDs

For the Mirror

  • 1x easily flexible mirror that you can see half of your body (We used a self-adhesive mirror foil and a desk mat)
  • 1x mounting for the mirror
  • 1x stepper – Used to bend the mirror
  • 3x long cords – It is used to bend the mirror and to keep it in place

How we Built the Scale

In the following the detailed steps of how we built the (naughty) scale are described:

Inspecting the Scale

On the same day that we received the topic of this year’s course “Sketching with Hardware”, we searched on for a suitable scale for our project. Immediately we found a wooden scale (see Image 3), which was only two underground stations away from our university. The scale was just perfect because it was made of wood and therefore suitable for further development. The next morning, we could pick it up and start our project.

Image 3: Scale “Soehnle Bamboo”

Next, we took a closer look at the microchip built into the scale. Unfortunately, we couldn’t find a data sheet on the internet for it and the company did not provide it either. We could only notice that the chip was connected to 1) four load cells with three wires each (for the cathode, anode and the data stream), 2) a button to turn on the display, 3) electricity wires to power the scale with batteries and, 4) the display.

Image 4: Detailed View of the Microchip Built in the Scale

Image 5: Scale Opened

Without the data sheet, we could not read the measured data from the scale and use it for further developments. That’s why we had to come up with another idea to read, use and display the weight on the scale. On the Internet we found many tutorials that said that it is easier to build your own scale just with the load cells of the scale. In many tutorials it was suggested to use the analog-to-digital converter (ADC) “HX711” to amplify the signals of the four load cells and report them to the Arduino. Said, done! We ordered the ADC and waited for it to  be delivered…

Analog-to-Digital Converter (ADC) – HX711

Just one day later we had the amplifier “HX711” delivered directly to our workshop. We had to cut off all the wires of the microchip used in the scale and connect the four load cells to the Arduino via the amplifier (Image 6 and Image 7). A more detailed description of the functionality and use of the “HX711″ can be found in Jan’s blog entry: ” HX711″.

Image 6: Cutting off the Wires of the Scale

Image 7: HX711

–> see Jan’s blog post for a more detailed description

Calibrating the Scale

After the wires of the four load cells were connected through the ADC to the Arduino, we had to calibrate the scale. For the calibration of the scale, we followed this tutorial and used its source code. We needed a known weight for scaling, so on the first day we simply used a bottle of water to calibrate (see Image 8), but as this was not accurate enough, the next day we used a known weight (see Image 9).

Image 8: Calibrating the scale with a somewhat known weight – a full water bottle

Image 9: Calibrating with a known weight – a 1kg weight

–> You can find a more detailed description of the calibrating step in Jan’s tutorial as well.

7-Segment Display

Since we could read the weight of the scale, we wanted to display the weight as well. We used a 7-segment display with 11 pins.

How it works: A 7-Segment display consists of 7 LEDs, which are called segments and are arranged in the form of the digit “8”. However, most of the seven segment displays have 8 segments. The 8th segment is a dot on the right side of the digit. The segments are named from A to G and DP for point and can be controlled individually.

How to determine the pins on the display and connect them to the Arduino:

  1. Assign a number to each of the pins on the 7-Segment display
  2. Connect the ground wire to any pin.
  3. Connect the positive wire to every other pin and wait until one segment lights up.
    1. If no segment lights up, move the ground wire to the next pin and repeat the process (2-3). Do it until one segment lights up.
  4. As soon as the first segment lights up, write down the segment name (A-G, DP) and the corresponding pin on the display.
  5. Go to the next pin with the positive wire until you have figured out every segment with its corresponding pin.

Image 10: Determining of the Pins of the 7-Segment Display

In the end we defined eight segment pins and three digit pins. We assigned them to the Arduino pins as shown in the table below:

How to implement: Next, we used a library called SevSeg to control the display. The library works for single-digit as well as multi-digit seven segment displays.

You just need to update the variables “numDigits”, “digitPins” and “segmentPins” according to your assigned pins in the right order and you are able display the measured weight on the scale:

SevSeg sevseg; //Instantiate a seven segment controller object
byte numDigits = 3; // Amount of digits n
byte digitPins[] = { 2, 3, 4 }; // Digit pins in the order from digit 1 to digit n
byte segmentPins[] = { 5, 7, 11, 9, 8, 6, 12, 10 }; // Segment pins from A to G and DP
bool resistorsOnSegments = false; // 'false' means resistors are on digit pins
byte hardwareConfig = COMMON_ANODE; // See of SevSeg library for options
bool updateWithDelays = true;
bool leadingZeros = false; // Use 'true' if you'd like to keep the leading zeros

void setup() {
   //LED 7-Seg
   sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments, 
   updateWithDelays, leadingZeros);

void loop() {
   float weight = 12.1f; // get the weight from the scale here
   sevseg.setNumber(weight, -1);
   sevseg.refreshDisplay(); // Must run repeatedly

(Naughty) LED Strips Using Adafruit NeoPixel Library

After the basic functionality of measuring and displaying the weight on the scale was restored, we were able to finally make our scale naughty. As soon as the person using the scale gained weight from one to the other measurement, the scale turned on LED strips coloured in dark red, which we placed underneath the scale. On the other side, if the person lost weight we implemented a “party-mode” and the LEDs light up with a rainbow effect.

How to implement: We used 3 LED strips with 5 LED’s each and connected them with wires to one strip (see Image 11). To connect the wires, you just must connect “-“ to “-“, “+” to “+” and, the data wire to the data wire in a row. Be careful, to take care of the electric current direction, otherwise it will not work! As a last step you must connect the wires at the end of the strip to the Arduino (anode to anode, cathode to cathode and the data wire to a defined pin).

The source code for controlling the LED with the Adafruit NeoPixel library is simple:

#define LEDPIN 13
Adafruit_NeoPixel strip = Adafruit_NeoPixel(15, LEDPIN, NEO_GRB + NEO_KHZ800);

void setup() {
   strip.begin();; // Initialize all pixels to 'off'

void loop() {
   colorWipe(strip.Color(255, 0, 0)); // sets the LEDs to red

// Fill the dots one after the other with a color
void colorWipe(uint32_t c) {
   for (uint16_t i = 0; i < strip.numPixels(); i++) {
      strip.setPixelColor(i, c);

Image 11: LED Strips Connected Underneath the Scale

Building the Case to Hide the Arduino with all its Wires

To hide all the electronics, we built a wooden frame to put underneath the scale. Therefore, we took the scale size (30 cm x 30 cm) and cut a wooden board to the same size (see Image 12). Furthermore, we cut 3 wood billets (see Image 13) to a size that they fit the length of the feet of the scale and screwed them together to a frame, which is missing one side.

Image 12: Wooden Board

Image 13: Wood Billets Used to Built a Frame

Next, we screwed the frame onto the board and we were able to put the scale on the frame, which allowed us to place the Arduino between the scale and the frame (see Image 14). Be careful to build this frame planar, otherwise you do not get precise measurements of the scale!

Image 14: Arduino hidden between frame and scale

How We Built the (Naughty) Mirror

In the following paragraphs you can see how we built the (naughty) mirror:


First, we did some prototyping to construct our naughty mirror as you can see in the image 15. We glued foam onto a stick, put cords through the right and left side of the form and connected them a servo, which was controlled by the Arduino. That way we were able to bend the form to the front. This worked well and that’s why we used this construction for our mirror, to bend it and to distort the mirror image that people look fatter as soon as the mirror is bend.

Image 15: Prototyping the Mirror

Selecting the Materials for the (Naughty) Mirror

The main characteristic of the mirror is that it can be bend forth and back to achieve the effect of appearing bigger in the mirror. For that reason, normal mirrors are not suitable, and we had to search for another alternative. First, we thought about aluminium foil, but the mirror effect of it was too small. Next, we went to an art supplies shop and found a self-adhesive mirror foil, which was just perfect for our project.

We also needed something to stick the mirror foil onto. We had a look at the rear panel of a cupboard, a floor protection mat and a desk mat. The best solution would be the floor protection mat as it is the easiest item to bend. However, the desk mat was way cheaper, so we decided to go with it. After that we glued the foil onto the desk mat it looked like this (Image 16):

Image 16: Mirror with Protectionfoil

Furthermore, we built a mounting for the mirror out of wood, tubes and a lot of adhesive tape as you can see in the images 17 and 18:

Image 17: Mounting (1)

Image 18: Mounting (2)

Bend the (Naughty) Mirror with a Stepper

We put the mirror on a table in front of the scale so that people who are standing on the scale can see themselves from their head to their knees in the mirror. On each side of the mirror we fixed a cord in the middle, which was connected to a stepper motor fixed at the front of the scale.

The stepper was used to spin the cords around the spinning part of the stepper. As soon as it started turning the cords were strengthened and the mirror was bent slowly. This had the effect that you see yourself getting bigger in the mirror slowly.

How to implement: We used the AccelStepper library to move our stepper:

#define motorPin1  22 // IN1 on the ULN2003 driver 1
#define motorPin2  24 // IN2 on the ULN2003 driver 1
#define motorPin3  26 // IN3 on the ULN2003 driver 1
#define motorPin4  28 // IN4 on the ULN2003 driver 1
#define HALFSTEP 8

// Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper with 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);

void setup() {

void loop() {
   // move the stepper to new position
   while (stepper1.distanceToGo() != 0) {;

How the Scale and Mirror Worked Together – Ready to Rumble

We placed the mirror on a table in front of the scale so that people can see themselves while standing on the scale from the head to their knees in the mirror (Image 19). We adjusted the length of the cords from the mirror to the stepper so that they were straight, but did not bend the mirror . Furthermore, we placed the 3 digit 7-Segment Display on top of the scale (Image 20). A schematic representation can be seen in image 1 at the beginning of this post as well.

Image 19: The Naughty Weighn – Ready to Rumble

Image 20: Detailed View of the Scale of the Naughty Weighn

As soon as the scale had measured a lower weight than last time, the scale began to celebrate. Instead of LED’s shining in a dark red light, they now shone in the colors of a rainbow.

As soon as the scale measured a higher weight than the last time, the “naught-o-mation” took place:

  1. The LEDs underneath the scale light up in dark red and
  2. The stepper started to turn and wrapped the strings around the stepper, which were attached to the mirror. This caused the mirror to bend forward, making it look like you’re getting a little thicker all the time.

What a Naughty Weighn 😈😈😈


linked categories 2018b, Projects


Write a comment


[…] Naughty Weighn, known from Julia’s blog post, is a smart scale for human measurements. Built from a used scale purchased for exactly one purpose […]