At the end of each chapter I quickly summarize what we accomplished and info boxes shed some additional light on aspects which might be new for beginners. The ebook is available on all Amazon Kindle stores (US, DE, etc.) just search for “ESP8266 Weather Station” or follow this link:
https://www.amazon.com/ESP8266-Weather-Station-Getting-Started-ebook/dp/B01LFX8Z5W/

Let me know what you think of it!

Before we begin

Just a little word of warning: you might  be taking apart a working digital body scale. I cannot guarantee that your retrofitting will actually work and you might end up having just a broken body scale. Because of this I recommend that you are using a cheap or old digital scale rather than an expensive working one…
The other thing I’d like to mention: it took me many hours of my scarce free time to build and document this project. While I am not depending on income from this blog I still very much appreciate teleported beer (donation), you following one of my affiliate links or buying something from my shop. Thank you!
This is a write up of a project I started about a year ago. The project went back onto my “work-in-progress stack” and was waiting for a revival. Back then I also wrote a quick article about it.

What you will need

The components I used in my project set me back between USD $30-40 including the body scale. The following list should give you an idea what components you’ll need and what you should be looking for.

Image	Description	Where to buy
	Digital Body Scale: It is very practical if you can build your smart scale project on an existing digital scale. From what I can tell modern digital scales all use the same kind of sensor (load cell) but I cannot guarantee it	Switzerland: Coop. IKEA also has a low-cost scale: IKEA
	The ESP8266 module is the next important component. It is the brain and mouth of your smart scale. I recommend a small development module like the Wemos D1 Mini: it has enough pins and is small	Banggood
	The HX711 module is a so called Load Cell Amplifier and will convert the weak analog signal from the weight sensor into bits and bytes the ESP8266 can understand.	Banggood
	Power Source - I picked a Lifepo4 AA-type battery since it provides the perfect voltage and has a considerable amount of capacity. The AA packaging (14500) also helps to buy or 3d print a good holder. If you don't own a 3d printer also buy a AA-cell holder	AliExpress
	These OLED displays are just wonderful: since the pixels glow by themselves the contrast is very high. You can choose between the 0.96 inch SSD1306 display or the 1.3 inch SH1106 one. The smaller one you can buy in the Squix Shop, the other you'll have to order from AliExpress or similar	0.96" Oled Display: Banggood 1.3" Oled Display: Banggood

Besides these “core” components you will also require wires, solder and solder iron, screw drivers.

Understanding the Body Scale

So here is the plan: you open up your pretty body scale, remove everything you don’t need and keep the load cells (the components which measure the weight) in place. Then you connect the load cells to your HX711 amplifier module and connect the amplifier to your ESP8266. Then you’ll need to attach the OLED display to the ESP8266 as well and bring in some kind of power source with an on-off switch. Easy, isn’t it?

For me the hardest part was to figure out how the load cells should be connected to the HX711. Luckily the load cells were attached to a mini PCB which in turn was soldered with only a few pins to the main board of the body scale. So I only had to figure out how to connect the four pins of the mini PCB to the HX711 module rather than figuring out how to connect the 12 wires of the load cells (3 wires and 4 load cells). I don’t know how your scale will look like. Maybe you will be lucky as well but it also could be that you have to do some hard core reverse engineering. Maybe the following pictures will help.

I suggest that you test the setup on a bread board before you take out the soldering iron. This way you can easily switch the wires until everything works. SparkFun has a very good introduction to load cells and the HX711: Sparkfun Load Cell Tutorial

Connecting the load cells and the HX711 Amp

Now that we (hopefully) have figured out how to use the existing load cells we have to connect them to the amplifier and the amplifier to the ESP8266.

Again, how you connect the load cells to the HX711 requires a bit of educated guessing. Read through the previous chapter, read the SparkFun tutorial about load cells, use the color codes of the wires. Then connect the HX711 to the ESP8266. The following image is just a zoomed in version of the complete wiring below:

Connecting the OLED display

If you are familiar with my WeatherStation project or the ESP8266 based plane spotter then the wiring of the OLED display should be straight forward. Just connect VCC on the display with 3V3 on the ESP8266, GND with GND, SDA on the display with D6 on the ESP and SCL with D7. In theory you can choose any D-pin for SDA and SCL, just make sure that they don’t have special functions. I think D8 is required for programming, others might be used for flash access. Also when you use the pins I suggest here you won’t have to change anything with my code. Please have a look at the complete sketch below for a graphical representation of the setup.

Connecting the power source

Now to my new favourite power source in the ESP8266 world: the LiFePo4 AA battery. After watching the excellent video of my fellow (Swiss) country man Andreas Spiess about ESP8266 battery sources I immediately ordered a few from AliExpress. The beauty is that their voltage range matches the 3V3 operation voltage of the ESP8266 perfectly. You don’t need any linear voltage regulator or boost up/down converter which just turn a considerable part of the battery’s capacity into heat. The discharge characteristic of the LiFePo4 also shows that it keeps providing a ESP8266 compatible voltage over a long time. For simplicity (and due to lack of necessary skills;-)) I decided to use a switch which was already built into the scale as on/off switch. An automatic power-saving circuit would have been nice but that would have complicated the project even more. In the original setup the built-in switch could be used to change between pounds and kilograms, now it will serve as the power switch.

The complete hardware setup

The following diagram shows you how to connect all the components together. As suggested earlier I recommend that you wire everything up on a breadboard first. In the next chapter we will to a first smoke test and also a quick calibration of the sensors. Let me know when you are ready;-).

Smoke Test and Calibration

While I use the term “smoke test” quite often in my daily software engineering routine I only learned recently that the expression originates from electronics: if you turn the device on and there is no smoke coming from the circuit you passed the first phase.

Let’s do a bit more and use a little program to see if the load cells are responding. While the “real” smart scale project will be using the Platformio environment I decided to use the Arduino IDE for this smoke test. This way you will have a starting ground even if you don’t get adjusted to the Platformio IDE. OK? So let’s get started:

1. If you haven’t done so, install the latest Arduino IDE. I am currently using 1.6.9
2. Download this library as zip file: https://github.com/bogde/HX711 and add the zip to the Arduino IDE by Sketch > Include Library… > Add .ZIP library…
3. For the testing of the OLED display also make sure you have my OLED library installed: Sketch > Include Library > Manage libraries… Search for “ESP8266 Oled Driver for SSD1306 display” by Daniel Eichhorn and Fabrice Weinberg. At the time of writing the last version is 3.2.6
4. Compile and upload the following code:

   #include <HX711.h>
   
   // Scale Settings
   const int SCALE_DOUT_PIN = D2;
   const int SCALE_SCK_PIN = D3;
   
   HX711 scale(SCALE_DOUT_PIN, SCALE_SCK_PIN);
   
   void setup() {
     Serial.begin(115200);
     scale.set_scale();// <- set here calibration factor!!!
     scale.tare();
   }
   
   void loop() {
     float weight = scale.get_units(1);
     Serial.println(String(weight, 2));
   }
   

5. Now check the serial monitor. If you see some non-static numbers then the HX711 is probably setup correctly.
6. Now to calibration. Basically you have to use a known weight and adjust the values by a certain factor. I used my kitchen scale and two tetra packs of milk which weight 2.120kg. Put the same weight on the body scale, take the readings and use the result of the reading divided by the expected value as factor in set_scale(..). If that was confusing, check out the following pictures. Note: at a later stage you should repeat calibration with bigger weights than just two kilograms, e.g. your own weight. This should increase accuracy…

And now as a last step of the smoke test let’s use the OLED display to show the weight:

// change if your are using SSD1306
//#include <SSD1306Wire.h>
#include <SH1106Wire.h>
#include <OLEDDisplayFonts.h>
#include <HX711.h>


// Scale Settings
const int SCALE_DOUT_PIN = D2;
const int SCALE_SCK_PIN = D3;

// Display Settings
const int I2C_DISPLAY_ADDRESS = 0x3c;
const int SDA_PIN = D6;
const int SDC_PIN = D7;

HX711 scale(SCALE_DOUT_PIN, SCALE_SCK_PIN);

// change if your are using SSD1306
SH1106Wire        display(I2C_DISPLAY_ADDRESS, SDA_PIN, SDC_PIN);
//SSD1306Wire      display(I2C_DISPLAY_ADDRESS, SDA_PIN, SDC_PIN);

void setup() {
  Serial.begin(115200);
  display.init();
  display.flipScreenVertically();
  scale.set_scale(-47941.0 / 2.122);
  scale.tare();
}

void loop() {
  String weight = String(scale.get_units(1), 2);
  Serial.println(weight);
  display.setFont(ArialMT_Plain_24);
  display.setTextAlignment(TEXT_ALIGN_LEFT);
  display.clear();
  display.drawString(0, 0, weight);
  display.display();
}

If you see now a frequently updated number on the OLED display then: congratulations! You have successfully destroyed a working body scale, removed a lot of parts and put new ones in and it works again! (Why did we do this again!?!)

Optional: 3D Printed Parts

There is a saying: when you have a hammer, everything looks like a nail. Well, my current hammer is a Printrbot Play and I am constantly looking for justifications why I spent (only) 400 bucks on a useless machine (my wife thinks so;-)). It so happens that I found two “nails” for 3D printing in this project: The AA battery holder and the foot mounts. The battery holder will accommodate the LiFePo4 battery, while the foot mounts became necessary since there wasn’t enough space beneath the scale for the battery. The battery holder is a wonderful parametric OpenScad project from Thingiverse: http://www.thingiverse.com/thing:456900 Since I only had a single cell I parametrized the print accordingly. The foot mounts I designed myself in OpenScad using the measurements from a digital caliper.

Summary and Outlook

This was part 1 of the SmartScale write-up which explained you the hardware setup. After working through this article you now have hopefully a working but still pretty dumb body scale. In part 2 I will guide you through the software setup. If you don’t want to miss it please sign up for my Newsletter here. You will only ever receive emails related to my project:

A few features that the SmartScale will have:

• Over-the-Air Update: Just turn on the body scale in the bathroom and deploy a new version of the software
• Blynk App Integration: see wonderful historical statistics and live data on your smart phone
• Change between Kilograms and Pounds through the Blynk App
• Energy saving mode: turn off the HX711 and the NodeMCU after 5min of inactivity. This will not be perfect but better than burning through the battery as quickly as possible;-)
• Displaying the Weather Forecast, so that you know which clothes to pick after the shower
• Do simple settings by using the load cell as input device

What you’ll need

In order to get this project running you’ll need the following list of hardware:

	NodeMCU ESP8266 module or Wemos D1 Mini
	0.96" SSD1306 OLED display
	A few connectors and USB Wire
	Or order a complete starter kit for USD $19.90 (incl. shipping) from my shop and support this blog. Do you live in the US? Then you can also order the Kit from Amazon

Depending on the coverage of adsbexchange.com feeders in your area you might also buy the following items:

• Raspberry Pi (Model 3 recommended but also works with older versions and probably Zero)
• RTL-SDR dongle for receiving the ADS-B signal
• Micro SD card for Raspberry Pi (for Model 3 or with adapter, depending on your RasPi model)

The Service – ADSBExchange

At the core of this project is the excellent service provided by Dan Streufert and countless people feeding live transponder signals into it: http://adsbexchange.com. From what I understand it is built on top of the http://www.virtualradarserver.co.uk/ project and lets you query live position data based on location, distance to a point, altitude etc and returns a JSON object which you can process in your code. Please note: in order to keep this service free-to-use Dan depends on your support, either by donating money to cover the server hosting costs or by providing your local data to improve coverage.

Note, this step is optional: When I first checked the coverage of the Zurich airport wasn’t so great so I decided to reactivate my RTL-SDR DVB-T dongle (see posts here, here and here) and contribute live data to adsbexchange.com. If the coverage in your area is insufficient consider to setup such a feeder as well.

Once you have the hardware (see above, Raspberry Pi and RTL-SDR dongle) you can either do the setup manually or take a short cut by becoming a flightaware feeder and using their ready-to-feed sd-card image called PiAware: http://flightaware.com/adsb/piaware/install. Once you have done that you have to setup your PiAware instance to also feed to adsbexchange.com by running a script provided by Dan: http://www.adsbexchange.com/how-to-feed/

The Plane Spotter Hardware

Once you are sure you have a good coverage of your area of interest you can start to get to the actual plane spotter hardware. I recommend to either use the components provided by my IoT Starter Kit or to get the setup I described in this post using the Wemos D1 Mini which requires soldering but yields a very compact setup. The wiring is described here.

The Code

UPDATE: this section describes the Platformio IDE project setup. In the meantime I have made it available also as example project in the WeatherStation library. Read more about it here if you prefer the Arduino IDE.

In my recent ESP8266 projects I started switching to the PlatformIO IDE since it is a lot more convenient to use compared to the Arduino IDE: automatic library dependency management, better coding support in the editor and great Travis CI and even Continuous Delivery support. So please make sure that you have a running IDE before you get started with the code. Once you have that ready please checkout the code from my github repository.

Now the most important part is to configure the QUERY_STRING variable in the main.cpp file:

const String QUERY_STRING = “lat=47.424341887&lng=8.568778038&fDstL=0&fDstU=10&fAltL=0&fAltL=1500&fAltU=10000”;

For a detailed description please checkout the documentation of the virtual radar server. What my example does is to filter out all aircrafts which are not within 10km from a location south of the runway and above 1500 feet (I don’t care about landed airplanes) or above 10000 feet (I also don’t care about transit airplanes). There are many options to adapt this query to your needs, so please carefully read the afore mentioned documentation. Once you are ready with the query you can flash the firmware on your ESP8266 chip.

First Run & Adapting it

Since the ESP8266 is fetching the data from the internet you’ll have to connect the module to the internet. My code is using the excellent WifiManager library. If your ESP8266 cannot connect to a (known) access point it will start an AP by itself and allow you to connect through your Wifi settings to it. A captive portal window opens and lets you select the correct SSID and enter the password. It then stores the Wifi settings on flash and will use it in the future.

If everything works you can go on and change the way the data is displayed or extract more data from the adsbexchange json object. It would be great if you could share your results with me either here in the comments or on Twitter. I’ll be happy to share it with the community.

Summary

You can build a cute little plane spotting tool with just a few components for under $20 without much work. If the coverage of your area on adsbexchange is poor then you could become a data feeder for about $50.- more (Raspberry Pi + RTL-SDR Dongle). Playing with the real-time data is fun and can be a very rewarding weekend project!

• Wifi Signal Quality icon in overlay
• Weather Icon, temperature and time in overlay
• By using Wifi Manager you can keep the wifi passwords out of your source code

How to get it running?

Download the Platformio IDE from here for your operating system and clone my github project. Now open the IDE and open the weather station project folder. No more need to install libraries manually, the platformio.ini file does this for you! You might still have to adapt:

• Your display pins (SDA & SCL)
• The Wunderground API key, location and language
• Your Thinkspeak credentials

Source Code

• https://github.com/squix78/esp8266-weather-station-platformio-demo

After turning, connecting and flashing different combinations of the two modules I finally found one that only requires you to solder 4 connections. Assuming that your display’s connectors are in the order GND, VCC, SCL and SDA just place the display on the bottom of your WeMos D1 Mini so that the two GND’s are connected with each other. VCC connects to D4, SCL to D3 and SDA to D2. I’m aware that I am “cheating” the D4 connector into being the power source, but I couldn’t find any data about the max. current the display draws. If you want to be 100% save add a connection between VCC (on the display) and 3V3 instead. Let me know in the comments if you are convinced that I’m doing something reckless.

If you are following my VCC-D4 hack from above make sure that you enable D4 for output and to set it to HIGH:

pinMode(D4, OUTPUT);
digitalWrite(D4, HIGH);

Resources

• WeatherStation on Github

Shopping List

• WeatherStation Kit for Soldering (you are supporting my blog)
• SSD1306 0.96 Inch Oled Display (from Banggood)
• WeMos D1 Mini (from Banggood)

Fabrice’s video below compares the the two I2C implementations:

Other changes:

• The font format was refactored for better memory efficiency and the web based font generator (http://oleddisplay.squix.ch/) now lets you generate font files for the older library versions or the new ones
• The hardware protocol level implementations (SPI, I2C) have been separated from the low level graphical functions. This affects how you instantiate the display classes
• To be open for future support of similar displays the core classes were renamed to Oled* instead of SSD1306
• More graphical functions have been added, including drawing of circles, non-vertical lines and a progress bar
• In case you want to use the display for simple log output you can now use print(..) and println(..) and the library will take care of scrolling. See Fabrice’s video below:

For a full list of new features and how to upgrade your existing code please have a look at the comprehensive upgrade guide: https://github.com/squix78/esp8266-oled-ssd1306/blob/master/UPGRADE-3.0.md

Please note: this release will break with your code based on the older 2.0.0 version. In case you have created fonts you’ll have to re-generate them as well. This also affects the Weather Station library!

Many thanks again to Fabrice Weinberg and all other contributors to make this release possible!

Today I got a wonderful email from Jens Lochmüller from Germany which shows that necessity is truly the mother of invention. He wanted to build a case for the Weather Station with a picture frame but since he didn’t have an unused one at home and the shops were closed today he just put it into the case of an old Nokia phone. If I had to guess I would say it is a Nokia 1110 or 1112.

Do you have other examples how you gave the Weather Station a new home? Please send me examples and I’m happy to blog about it!

Watch the full movie:

]]> https://blog.squix.org/2016/01/weather-station-in-old-nokia-phone.html/feed 0 13 https://blog.squix.org/2016/01/esp8266-weather-station-world-clock-demo.html https://blog.squix.org/2016/01/esp8266-weather-station-world-clock-demo.html#comments Fri, 01 Jan 2016 15:19:00 +0000 http://blog.squix.org/2016/01/01/esp8266-weather-station-world-clock-demo/ Read More

Just in time for the beginning of the new year I added a demo for the WeatherStation which displays various world times together with a pretty icon. Just update the WeatherStation library in your Arduino IDE to the latest version or download it manually from here: https://github.com/squix78/esp8266-weather-station
Then you can open the demo from File > Examples > ESP8266 Weather Station > WorldClockDemo

The used icons are designed by Adam Whitcroft: http://adamwhitcroft.com/offscreen/

Happy New Year!

]]> https://blog.squix.org/2016/01/esp8266-weather-station-world-clock-demo.html/feed 13 14 https://blog.squix.org/2015/12/esp8266-weather-station-measuring-2.html https://blog.squix.org/2015/12/esp8266-weather-station-measuring-2.html#comments Mon, 28 Dec 2015 20:39:00 +0000 http://blog.squix.org/2015/12/28/esp8266-weather-station-measuring-2/ Read More

]]>

Measuring Inside and Outside Temperature – Part 2>

The code you get with the WeatherStation (https://github.com/squix78/esp8266-weather-station) is meant as a starting point for beginners and enthusiasts to display information. So far there are modules to get correct time from the internet as well as current and future weather conditions. Now let’s get a bit more local.
What if you wanted to measure and display information from various places in your house or apartment? This blog post shows you how to attach a DHT22 temperature/humidity sensor either directly to the WeatherStation (in case you want to measure it where the WeatherStation is) or how to collect and display data from another room over WiFi.

Requirements & Preparation

For this tutorial I assume that you already have a working WeatherStation and a DHT22 breakout board ready.

	Product	Where to buy?
	The ESP8266 WeatherStation	Amazon (US) Squix Shop (World wide)
	DHT22 Humidity/ Temperature Sensor	Banggood
	NodeMCU V1.0	Banggood

 

Attaching the DHT22 to the ESP8266 directly to the WeatherStation

To measure temperature and humidity in the room where you are running the WeatherStation you can attach the DHT22 breakout board as shown in the schema bellow

ESP8266 WeatherStation with locally attached DHT22 sensor to measure temperature and humidity

Next you need to import the DHT22 library. This is easiest by using the library Manager:
Sketch > Include Library… > Manage Libraries…

And now search for the DHT library:

Now that you have the library you can start extending the demo. In order for this to work I assume that you have already done everything to get a working WeatherStation. Save your existing sketch under a new name. Here are the necessary changes:

 

Let’s discuss the changes:

• Line 37: I have added the DHT library
• Lines 77-83: configuration options for the DHT library. If you are using a DHT11 or DHT21 here you can change it. Also adapt the used pin. If you are not using the NodeMCU board D6 will give you a compile error
• Lines 104/105: two new variables for humidity and temperature. If this was a new WeatherStation module you would keep the variable in the new classes and not here, in a “global” scope…
• Lines 110-119: The prototypes help the compiler/linker to use functions which will only be used afterwards
• Lines 119/124: I added a new drawIndoor method and increased the number of frames to 6. Now the framework knows which method to call in order to draw the indoor information
• Lines 231-233: In this tutorial we update the temperature und humidity only once every 10 minutes. Updating the values only costs about 250ms but it might still be too much to do it in the hot (main) loop. But you could do it there every once in a while
• Lines 271-277: This draws the indoor frame. You might see a strong similarity to the drawThingspeak method. This is not coincidental since they draw similar data. In a perfect world we could extract this to an extra method to share the code

[the_ad_placement id=”inpostplacement”]

That’s it! Apply these changes to your code, compile it and flash your ESP8266 with the changes after you set up the wiring.

The result of successfully following this tutorial

Part two of this tutorial will show you how to read the information from another ESP8266 through the cloud…

Measuring Inside and Outside Temperature – Part 2>

]]> https://blog.squix.org/2015/12/esp8266-weather-station-measuring-2.html/feed 76 15