Getting Started

This module has much more features than what I will describe here. I will just show how to connect the module to your ESP8266, which library to install and how to run your first measurements within minutes.

1. Use four wires to connect the following pins:
   1. GND with GND
   2. VCC with V3V
   3. SLC with D5
   4. SDA with D6
2. Open your Arduino IDE and install the following library from Sketch > Include Library > Manage Libraries: VL53L0X by Polulu
3. Select from File > Examples > VL53L0X > Single the Example sketch and change the following line

   Wire.begin();

   into

   Wire.begin(D6, D5);

4. Compile your sketch, upload it to the ESP8266 and open the serial console. If everything went well you should see now the millimeters of distance measured by the laser-ranging sensor.

Pitfalls

At first my measurements were really inaccurate and I was disappointed that the values were always off by about 20mm! Then I searched the web and found out that often the sensor is covered by a protection. Remove this protection to get very precise measurements

Accuracy

After removing the protection the measurements were really good. I just tested values below 30cm and the were within 1mm accuracy. This might be a good option for a robotics project to apply SLAM.

Where to buy?

As always I bought this module from my preferred Online Shop: Banggood. With around USD $12.30 it is more expensive than the RCW-0001 but the accuracy is also a lot better.

Summary

The CJMCU-530 is a affordable and accurate laser-based range sensor. The break-out board offers many features (which I haven’t tested yet) but it is always promising to have more features to test after the initial run. Compatibility with the ESP8266 is good and you just need to change one line in the sample code to get it running with our preferred WiFi chip.

Links

• Shopping Link to Banggood
• Library from Polulu on Github

Connecting this display required a bit of creative thinking. At first I thought that the ESP8266 wouldn’t have enough pins to connect the display. I decided to strip some aspects and I’m honestly not 100% sure what the side effects are. The board comes with a temperature sensor and I decided to set the temperature manually to save pins. This probably yields better quality for displayed pictures.

[the_ad_placement id=”inpostplacement”]

Another problem was to figure out how the pins on the connector were arranged. Here the following schematic helped:

So here is how you connect it:

When you have connected the display download this sample code:
https://github.com/squix78/ePaperDemo1

I adjusted my OLED library for the SSD1306 to the ePaper display. It has the advantage that you first create the content of the ePaper display in a buffer. When you are ready to write everything to the display call the appropriate method and the content of the buffer will be written to the display. The library currently supports the following function:

• Draw Text at a given location. Define text alignment and get information how much space the text will consume
• Create custom font files with http://oleddisplay.squix.ch/ and include them in your firmware
• Draw lines, circles, boxes and fill them

I hope to extract a library from it but until then just use the demo code to get started with your own project.

I have been trying to use the popular HC-SR04 ultrasonic sensor together with the ESP8266 in the past but I wasn’t succesful. I guess this sensor needs 5V for proper operation and in order to do that I would have to add a voltage divider for the response pin to accommodate for the 3.3V of the ESP8266. So I went looking for a distance sensor working easily with the ESP8266 and I found it on Banggood for less than USD $5.

Get it to work

To get it to work with the ESP8266 in the Arduino IDE you need a library or write the code yourself. The first library that I tried worked almost immediately. Just download the library from here: https://bitbucket.org/teckel12/arduino-new-ping/wiki/Home

Then go to Sketch > Include Library > Add Zip library.. and you are good to go. Sadly the library doesn’t seem to be listed in the Arduino Library manager but the download and import by ZIP is easy enough. Now go to File > Examples > NewPing > New Ping Example which opens a new Sketch window. Now just change the pins according to your wiring. I think most GPIO pins will work but I used D4 and D3 on the NodeMCU. Connect

• VCC with 3.3V
• GND and GND,
• TRIG and D4 and
• ECHO and D3

My Sketch looks like this:

#include <NewPing.h>

#define TRIGGER_PIN D4 // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN D3 // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 400 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

void setup() {
 Serial.begin(115200); // Open serial monitor at 115200 baud to see ping results.
}

void loop() {
 delay(50); // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
 Serial.print(&quot;Ping: &quot;);
 Serial.print(sonar.ping_cm()); // Send ping, get distance in cm and print result (0 = outside set distance range)
 Serial.println(&quot;cm&quot;);
}

Then open the serial console and you get a wonderful stream of distance measurements!

Where to buy?

Order it now 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!

Specification

• Operating voltage: 3.3-5v
• Interface: I2C
• Detecting distance: 0~3m
• Horizontal detecting angle: 33 degrees
• Vertical detecting angle: 23 degrees
• Dimensions: 32mm x 16mm(1.26×0.63″)
• Resolution is 128×96 pixel, with 8 sub pixels, so 1024×768
• track four objects (IR emitting or reflecting objects)
• Cost: USD ~$23.55

How does it work? 

The chip in the sensor module does all the hard work for you: filtering the noise and figuring out the strongest sources of light that passed through the IR filter in front of the camera. It will send then 4 pairs of x and y coordinates through the I2C interface to your ESP8266 (or any other MCU). If no IR source was detected the pair will just return the maximal value for 2^10 = 1023. If a source has been detected it will return the coordinates with a resolution of 1024×768 pixels to you.

How to wire it to the ESP8266? How to program?

Just connect the RED pin to 3.3V, the BLACK to GND and the GREEN (e.g. D6) and YELLOW (e.g. D5) to a free GPIO pin. Then use the following script, adapt the GPIO pins if necessary and upload the script to your ESP8266:

How to visualize the results?

I used Processing to visualize the data points the ESP8266 returns over  the serial line. Here is the Processing script:

Then I used an IR bar I still had from my Nintendo Wii and waved it in front of the camera.

And here is the result:

What can you use the sensor for?

I bought it because I plan to help my robot navigate indoor with the help of the IR Camera. I’m not yet sure if then the camera should be on the robot and the IR sources all over the room or if several cameras should track the IR sources on the Robot and send its coordinates to the robot.

You could also build a whiteboard or a head tracker. Just search for Wiimote hack on Google and you’ll get plenty of ideas what you can do with the sensor!

Where to buy?

• DF Robot
• Aliexpress

Where can I get more resources?

• http://www.dfrobot.com/wiki/index.php/Positioning_ir_camera

The ESP8266 is all about Internet of Things, right? So lets start sensing something in the real world! What about (human) presence in your apartment? There are various ways to do that but one of the most common type is sensing with pyro electric sensors which also called passive infrared (PIR) sensors (see Wikipedia). The one I am presenting in this post is also a PIR sensor; a really tiny one and with its 3.3V support very suitable for the ESP8266.

Features

• Working voltage: DC 2.7-12V
• Static power consumption: I measured between 0.016mA (source detected) and 0.076mA (sensor active)
• Delay time: when detecting a source the sensor will hold the output high for 2 seconds
• Sensing range: ≤100 degree cone angle, about 2m, possibly more in friendlier environmentWorking
• Total size: Approx. 12mm x 25 mm

How to use it with the ESP8266?

Since the Mini PIR sensor can handle 3.3V its output level will be ESP8266 compatible. It only has three pins, one for Vin, GND and Data (output) pin. You can wire it up like this:

Connect

• 3.3V with Vin (left)
• D2 with Data (middle)
• GND with GND (right)

then paste this code to your Arduino IDE and upload it to the connected NodeMCU:

int oldValue = 0;

void setup() {
  // put your setup code here, to run once:
  pinMode(D2, INPUT_PULLUP);
  Serial.begin(115200);

}

void loop() {
  int value = digitalRead(D2);
  if (value != oldValue) {
    Serial.println("New Value: " + String(value));
    oldValue = value;
    if (value == 1) {
      Serial.println("##########################");
    }
  }
  delay(100);
}

 

Open the serial console and you should see movement in front of the sensor as output in your serial console.

 

Where to use?

The fact that there is no need of additional components makes this motion sensor very useful for a series of applications. While not detecting any heat source the sensor consumes 0.076mA and in the two seconds after detection even goes down to 0.016mA. So in theory the sensor alone could run on a 1200mAh battery for nearly two years.  Together with a clever circuit you can put the ESP8266’s CH_EN (chip enable) pin low and send it to an ultra deep sleep (0.5µA!!!) and only wake it up when motion has been detected. Read more in this post over at the ESP8266 forum how it can be done: http://www.esp8266.com/viewtopic.php?f=11&t=4458

The schema looks promising but I haven’t tried it out yet.

Pros and Cons

The low price, small form factor, the simple interface and its ability to handle a wide range of voltages makes it very convenient to use with the ESP8266. The detection range on the other hand seems to be rather short, I had accurate detections within about 2 meters. Nonetheless there are still many applications that you can use this module for…

 

Where to buy?

Order one now from Banggood

 

 

 

What is this module doing?

At least since the iPhone 3G came to the market GPS based navigation has become a commodity for many people. The global positioning system receives signals from satellites. If the signals of at least four satellites are received the position of the device can be calculated. It can do this by comparing small differences in the  time the signal took to reach the receiver. Since the satellites broadcast these signals with relatively weak signal the receiver requires direct line-of-sight to the satellites and this means pure GPS often doesn’t work well indoors.

Enough about the theory, how can the ESP8266 talk to the u-blox module? The module exposes the positioning information through a serial interface, just like the one you are using to program the ESP8266. By default it is set to 9600 baud but this value can be changed also through the serial interface. Apparently it is a very common thing that GPS modules have a serial interface and another partially standardized aspect is the message format. This module sends messages in the NMEA (0183 V3.0) format. This format knows many different types of messages, some of them are vendor specific. We are here interested in general messages. If you look directly at the serial output you will see messages like this:

$GPGSV,5,1,19,01,,,29,02,,,30,05,,,27,07,,,29*72
$GPGSV,5,2,19,08,,,23,10,,,28,12,,,32,13,,,29*7F
$GPGSV,5,3,19,15,,,26,16,,,28,18,,,27,21,,,26*71
$GPGSV,5,4,19,22,,,29,23,,,30,24,,,27,28,,,27*75
$GPGSV,5,5,19,29,,,29,33,,,30,40,,,30*75

Setting up the module with the ESP8266

Now that we have connected the u-blox module it is ready for our first code. We want to read the NMEA messages in the NodeMCU and forward them to the serial console on the PC. This code here does the trick:

#include <SoftwareSerial.h>

// if you are not using a NodeMCU but another type of ESP8266
// you might want to replace this with the correct GPIO pin numbers you used
SoftwareSerial mySerial(D5, D6); // RX, TX

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  // set the data rate for the SoftwareSerial port
  mySerial.begin(9600);

}

void loop() {
  if (mySerial.available()) {
    Serial.write(mySerial.read());
  }
  if (Serial.available()) {
    mySerial.write(Serial.read());
  }
}

Upload the sketch to your ESP and open the serial console. Now you should see the NMEA messages come in.
At first there might be values missing, but the more satellite signals the module receives the more complete the positioning information will be. After this first smoke test lets continue with a library that can make sense of the NMEA messages.

The TinyGPS+ library

By installing this library you can finally get to the core of the GPS information: latitude, longitude, altitude, speed, etc. Go to http://arduiniana.org/libraries/tinygpsplus/ and download the library, extract it to your Arduino/libraries folder and restart your Arduino IDE. Then go to File > Examples > TinyGPSPlus and open the FullExample file. Now you have to adapt the baud rate to 9600 (this is the default serial speed of our u-blox module) and change the serial pins to D5 and D6 and run the code.

static const int RXPin = D5, TXPin = D6;
static const uint32_t GPSBaud = 9600;

If you are not getting any position information you might want to get closer to the window or even go outside. Pure GPS is notoriously famous for not working indoors, due to the weak satellite signals and interference with other RF sources.

Application Ideas

Ok, great. Now we have a working GPS module. But what can we do with it? Here are a few ideas:

• Bike computer: mix together an OLED display, NodeMCU, a USB power bank and the GPS module and mount everything on your bike. With a little bit of code you can display information on the OLED display such as speed, altitude and you can use way points even to some basic navigation. Store the tracking data in the EEPROM and upload it to the cloud as soon as the device detects your home device
• War Drive Module: okay, I admit, this might not have the relevance anymore that it once had, but you could build it for less than USD $20! Wire up the GPS module and the NodeMCU and a Power Bank and bring it with you to work while it is running. Every 30 seconds or so list the SSID the NodeMCU lists through the Wifi Interface together with the location and store it in the EEPROM. Later use that information to create a map of (free?) Wifi access points
• High precision real time clock: In order to calculate your current position the satellite send highly precise time stamps which you can read with help of the TinyGPS+ library. True, you can use the network time protocol (NTP) to fetch the current time if your ESP is connected to the internet. But if you are offline for some reason the GPS clock might be handy. You could actually implement your own NTP server, backed by the GPS module

Review

The module is easy to use and with less than USD $10 it was a no-brainer to order it and to try it out. The serial interface makes it very convenient to use if you have two GPIO pins to spare. Without problems I could use the SoftwareSerial module so I still could be using the hardware serial interface for debugging. While I think it is a great module for your outdoor positioning project it doesn’t work very well indoors. Nowadays we are spoiled by quickly locking GPS modules on smartphones which also perform well indoors. But be warned: the GPS module isn’t as good as that, since it cannot use information like (GSM) cell Ids or Wifi SSIDs to improve speed and accuracy of the position signal. But the module will be a great addition to your tool box for your next project (see ideas above). I forgot to mention that the GPS module has a convenient way to save energy in case you don’t need it: setting the yellow pin to LOW will basically shutdown the module completely.

Order the module now from Banggood

The start makes an input device which is surprisingly low tech but offers a nice way to adjust settings on a display without using too much of your valuable GPIO pins: the KY-040 rotary encoder

What is a Rotary Encoder?

At first glance you might mistake the KY-040 for an adjustable resistor, a potentiometer. It has a knob which you can turn. But unlike real potentiometers the KY-040 can turn round and round without ever getting to a blocking limit. When turning the KY-04 you will also feel certain positions where the encoder will slide into. A potentiometer on the other hand can usually be turned smoothly until you get to the end stop. And there is another difference: the KY-040 (like most rotary encoders) has a switch which can be closed when pressing the knob vertically to the rotation axis. I have seen rotary encoders like this being used in modern radios or in built-in car navigation systems. The advantage is that they can be used relatively easy in a digital system as opposed to an analog/digital converter (ADC) reading the values from a potentiometer. There you also might have to deal with temperature drift and similar ugly problems. So in many ways a rotary encoder is the younger (millennial/digital) brother of a potentiometer.

How do you use  a Rotary Encoder?

There are different types of rotary encoders. Some can determine the absolute position/angle of the knob without constantly keeping track of its movements. But the KY-040 a very simple minded fellow. By tracking the signals on two pins an MCU can determine if the knob was turned to the left or to the right. With a third pin the state of the knob button can be tracked. The wave form on the two rotation pins looks more or less like this:

Lets get our hands dirty!

Now to a practical example. Wire up your encoder like this the following picture, make sure that you follow the labels and not the ordering, I might have turned something upside down:

• GND to GND
• + to 3.3V
• SW to D3
• DT to D2
• CLK to D1

Installing the library

There are different libraries that might work. This library worked well for me: https://github.com/PaulStoffregen/Encoder Download the ZIP and unpack it into your Arduino library directory. Restart the Arduino IDE and copy the code from here:

#include <Encoder.h>

Encoder myEnc(D1, D2);


long oldPosition  = -999;
boolean isButtonPressed = false;
long lastUpdateMillis = 0;

void handleKey() {
  isButtonPressed = true;  
}

void setup() {
  Serial.begin(115200);
  Serial.println("Basic Encoder Test:");
   pinMode(D3, INPUT_PULLUP);
   attachInterrupt(D3, handleKey, RISING);
}


void loop() {
  long newPosition = myEnc.read();
  if (newPosition != oldPosition) {
    oldPosition = newPosition;
    Serial.println(newPosition);
  }
  // software debounce
  if (isButtonPressed &amp;&amp; millis() - lastUpdateMillis &gt; 50) {
    isButtonPressed = false;
    lastUpdateMillis = millis();
    // Reset the counter
    myEnc.write(0);
  }
}

After uploading the sketch you can open the serial console, turn the knob up and down and press the axis to reset the counter. Your output might look something like this:

Basic Encoder Test:
0
1
2
3
2
3
4
0 - Knob pressed
1
2
3
4
0 - Knob pressed

Suggested applications

• WeatherStation Frame Controller: Some readers were asking me how they could control the currently displayed frame of the WeatherStation. Depending on the amount of the frames you are using it might take a while until the one that interests you the most comes around. The rotary encoder is a nice extension which allows you to quickly zap through the frames without having to implement a lot of code
• Wifi Selector for unprotected APs: lets assume you have a setup with an ESP8266, a display and you want to quickly select an unprotected wifi to connect to without using the web interface: just implement some kind of menu and use the rotary encoder to move a cursor from one SSID to the next and the knob button to select the AP you actually want to connect to

Where to buy?

As always I recommend to order it from my favourite Chinese retailer Banggood

Motorshield

NodeMCU V1.0 Powershield

Smart Car Kit

The Smart Car Kit

Bringing it together: the WiFi Car

Programming the Car from the Arduino Environment

Shopping List:

Connect the Modules like this:

Here you’ll find the library:
https://github.com/squix78/MAX7219LedMatrix

Please note:

• this library is made for the ESP8266 and might or might not work for “normal” Arduino boards.
• I had to patch the Mac OS X release with the SPI folder from Github. In other words there wasn’t an up-to-date release for Mac OS X (and maybe for the other platforms as well) and the SPI.h/SPI.cpp wouldn’t compile